Use IdeClient directly instead of config.ideClient (#7627)

packages/cli/src/gemini.tsx

@@ -36,9 +36,6 @@ import {
   logUserPrompt,
   AuthType,
   getOauthClient,
-  logIdeConnection,
-  IdeConnectionEvent,
-  IdeConnectionType,
   uiTelemetryService,
 } from '@google/gemini-cli-core';
 import { validateAuthMethod } from './config/auth.js';
@@ -289,11 +286,6 @@ export async function main() {
     spinnerInstance.unmount();
   }
 
-  if (config.getIdeMode()) {
-    await config.getIdeClient().connect();
-    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.START));
-  }
-
   // Load custom themes from settings
   themeManager.loadCustomThemes(settings.merged.ui?.customThemes);
 

packages/cli/src/services/BuiltinCommandLoader.test.ts

@@ -64,7 +64,7 @@ describe('BuiltinCommandLoader', () => {
     vi.clearAllMocks();
     mockConfig = { some: 'config' } as unknown as Config;
 
-    ideCommandMock.mockReturnValue({
+    ideCommandMock.mockResolvedValue({
       name: 'ide',
       description: 'IDE command',
       kind: CommandKind.BUILT_IN,
@@ -81,7 +81,7 @@ describe('BuiltinCommandLoader', () => {
     await loader.loadCommands(new AbortController().signal);
 
     expect(ideCommandMock).toHaveBeenCalledTimes(1);
-    expect(ideCommandMock).toHaveBeenCalledWith(mockConfig);
+    expect(ideCommandMock).toHaveBeenCalledWith();
     expect(restoreCommandMock).toHaveBeenCalledTimes(1);
     expect(restoreCommandMock).toHaveBeenCalledWith(mockConfig);
   });
@@ -105,7 +105,7 @@ describe('BuiltinCommandLoader', () => {
     const loader = new BuiltinCommandLoader(null);
     await loader.loadCommands(new AbortController().signal);
     expect(ideCommandMock).toHaveBeenCalledTimes(1);
-    expect(ideCommandMock).toHaveBeenCalledWith(null);
+    expect(ideCommandMock).toHaveBeenCalledWith();
     expect(restoreCommandMock).toHaveBeenCalledTimes(1);
     expect(restoreCommandMock).toHaveBeenCalledWith(null);
   });

packages/cli/src/services/BuiltinCommandLoader.ts

@@ -64,7 +64,7 @@ export class BuiltinCommandLoader implements ICommandLoader {
       editorCommand,
       extensionsCommand,
       helpCommand,
-      ideCommand(this.config),
+      await ideCommand(),
       initCommand,
       mcpCommand,
       memoryCommand,

packages/cli/src/ui/App.test.tsx

@@ -93,7 +93,6 @@ interface MockServerConfig {
   getAllGeminiMdFilenames: Mock<() => string[]>;
   getGeminiClient: Mock<() => GeminiClient | undefined>;
   getUserTier: Mock<() => Promise<string | undefined>>;
-  getIdeClient: Mock<() => { getCurrentIde: Mock<() => string | undefined> }>;
   getScreenReader: Mock<() => boolean>;
 }
 
@@ -183,13 +182,6 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
         getWorkspaceContext: vi.fn(() => ({
           getDirectories: vi.fn(() => []),
         })),
-        getIdeClient: vi.fn(() => ({
-          getCurrentIde: vi.fn(() => 'vscode'),
-          getDetectedIdeDisplayName: vi.fn(() => 'VSCode'),
-          addStatusChangeListener: vi.fn(),
-          removeStatusChangeListener: vi.fn(),
-          getConnectionStatus: vi.fn(() => 'connected'),
-        })),
         isTrustedFolder: vi.fn(() => true),
         getScreenReader: vi.fn(() => false),
         getFolderTrustFeature: vi.fn(() => false),
@@ -208,6 +200,15 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     MCPServerConfig: actualCore.MCPServerConfig,
     getAllGeminiMdFilenames: vi.fn(() => ['GEMINI.md']),
     ideContext: ideContextMock,
+    IdeClient: {
+      getInstance: vi.fn().mockResolvedValue({
+        getCurrentIde: vi.fn(() => 'vscode'),
+        getDetectedIdeDisplayName: vi.fn(() => 'VSCode'),
+        addStatusChangeListener: vi.fn(),
+        removeStatusChangeListener: vi.fn(),
+        getConnectionStatus: vi.fn(() => 'connected'),
+      }),
+    },
     isGitRepository: vi.fn(),
   };
 });

packages/cli/src/ui/App.tsx

@@ -59,7 +59,12 @@ import { ContextSummaryDisplay } from './components/ContextSummaryDisplay.js';
 import { useHistory } from './hooks/useHistoryManager.js';
 import { useInputHistoryStore } from './hooks/useInputHistoryStore.js';
 import process from 'node:process';
-import type { EditorType, Config, IdeContext } from '@google/gemini-cli-core';
+import type {
+  EditorType,
+  Config,
+  IdeContext,
+  DetectedIde,
+} from '@google/gemini-cli-core';
 import {
   ApprovalMode,
   getAllGeminiMdFilenames,
@@ -73,6 +78,7 @@ import {
   isGenericQuotaExceededError,
   UserTierId,
   DEFAULT_GEMINI_FLASH_MODEL,
+  IdeClient,
 } from '@google/gemini-cli-core';
 import type { IdeIntegrationNudgeResult } from './IdeIntegrationNudge.js';
 import { IdeIntegrationNudge } from './IdeIntegrationNudge.js';
@@ -161,10 +167,19 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const { history, addItem, clearItems, loadHistory } = useHistory();
 
   const [idePromptAnswered, setIdePromptAnswered] = useState(false);
-  const currentIDE = config.getIdeClient().getCurrentIde();
+  const [currentIDE, setCurrentIDE] = useState<DetectedIde | undefined>();
+
   useEffect(() => {
-    registerCleanup(() => config.getIdeClient().disconnect());
+    (async () => {
+      const ideClient = await IdeClient.getInstance();
+      setCurrentIDE(ideClient.getCurrentIde());
+    })();
+    registerCleanup(async () => {
+      const ideClient = await IdeClient.getInstance();
+      ideClient.disconnect();
+    });
   }, [config]);
+
   const shouldShowIdePrompt =
     currentIDE &&
     !config.getIdeMode() &&
@@ -306,7 +321,7 @@ const App = ({ config, settings, startupWarnings = [], version }: AppProps) => {
   const { isFolderTrustDialogOpen, handleFolderTrustSelect, isRestarting } =
     useFolderTrust(settings, setIsTrustedFolder);
 
-  const { needsRestart: ideNeedsRestart } = useIdeTrustListener(config);
+  const { needsRestart: ideNeedsRestart } = useIdeTrustListener();
   useEffect(() => {
     if (ideNeedsRestart) {
       // IDE trust changed, force a restart.

packages/cli/src/ui/commands/aboutCommand.test.ts

@@ -10,8 +10,20 @@ import { type CommandContext } from './types.js';
 import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
 import * as versionUtils from '../../utils/version.js';
 import { MessageType } from '../types.js';
+import { IdeClient } from '@google/gemini-cli-core';
 
-import type { IdeClient } from '../../../../core/src/ide/ide-client.js';
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...actual,
+    IdeClient: {
+      getInstance: vi.fn().mockResolvedValue({
+        getDetectedIdeDisplayName: vi.fn().mockReturnValue('test-ide'),
+      }),
+    },
+  };
+});
 
 vi.mock('../../utils/version.js', () => ({
   getCliVersion: vi.fn(),
@@ -27,7 +39,6 @@ describe('aboutCommand', () => {
       services: {
         config: {
           getModel: vi.fn(),
-          getIdeClient: vi.fn(),
           getIdeMode: vi.fn().mockReturnValue(true),
         },
         settings: {
@@ -53,9 +64,6 @@ describe('aboutCommand', () => {
     Object.defineProperty(process, 'platform', {
       value: 'test-os',
     });
-    vi.spyOn(mockContext.services.config!, 'getIdeClient').mockReturnValue({
-      getDetectedIdeDisplayName: vi.fn().mockReturnValue('test-ide'),
-    } as Partial<IdeClient> as IdeClient);
   });
 
   afterEach(() => {
@@ -129,11 +137,11 @@ describe('aboutCommand', () => {
   });
 
   it('should not show ide client when it is not detected', async () => {
-    vi.spyOn(mockContext.services.config!, 'getIdeClient').mockReturnValue({
+    vi.mocked(IdeClient.getInstance).mockResolvedValue({
       getDetectedIdeDisplayName: vi.fn().mockReturnValue(undefined),
-    } as Partial<IdeClient> as IdeClient);
+    } as unknown as IdeClient);
 
-    process.env.SANDBOX = '';
+    process.env['SANDBOX'] = '';
     if (!aboutCommand.action) {
       throw new Error('The about command must have an action.');
     }

packages/cli/src/ui/commands/aboutCommand.ts

@@ -5,10 +5,11 @@
  */
 
 import { getCliVersion } from '../../utils/version.js';
-import type { SlashCommand } from './types.js';
+import type { CommandContext, SlashCommand } from './types.js';
 import { CommandKind } from './types.js';
 import process from 'node:process';
 import { MessageType, type HistoryItemAbout } from '../types.js';
+import { IdeClient } from '@google/gemini-cli-core';
 
 export const aboutCommand: SlashCommand = {
   name: 'about',
@@ -29,10 +30,7 @@ export const aboutCommand: SlashCommand = {
     const selectedAuthType =
       context.services.settings.merged.security?.auth?.selectedType || '';
     const gcpProject = process.env['GOOGLE_CLOUD_PROJECT'] || '';
-    const ideClient =
-      (context.services.config?.getIdeMode() &&
-        context.services.config?.getIdeClient()?.getDetectedIdeDisplayName()) ||
-      '';
+    const ideClient = await getIdeClientName(context);
 
     const aboutItem: Omit<HistoryItemAbout, 'id'> = {
       type: MessageType.ABOUT,
@@ -48,3 +46,11 @@ export const aboutCommand: SlashCommand = {
     context.ui.addItem(aboutItem, Date.now());
   },
 };
+
+async function getIdeClientName(context: CommandContext) {
+  if (!context.services.config?.getIdeMode()) {
+    return '';
+  }
+  const ideClient = await IdeClient.getInstance();
+  return ideClient?.getDetectedIdeDisplayName() ?? '';
+}

packages/cli/src/ui/commands/bugCommand.test.ts

@@ -16,7 +16,19 @@ import { formatMemoryUsage } from '../utils/formatters.js';
 vi.mock('open');
 vi.mock('../../utils/version.js');
 vi.mock('../utils/formatters.js');
-vi.mock('@google/gemini-cli-core');
+vi.mock('@google/gemini-cli-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@google/gemini-cli-core')>();
+  return {
+    ...actual,
+    IdeClient: {
+      getInstance: () => ({
+        getDetectedIdeDisplayName: vi.fn().mockReturnValue('VSCode'),
+      }),
+    },
+    sessionId: 'test-session-id',
+  };
+});
 vi.mock('node:process', () => ({
   default: {
     platform: 'test-platform',
@@ -31,9 +43,6 @@ describe('bugCommand', () => {
   beforeEach(() => {
     vi.mocked(getCliVersion).mockResolvedValue('0.1.0');
     vi.mocked(formatMemoryUsage).mockReturnValue('100 MB');
-    vi.mock('@google/gemini-cli-core', () => ({
-      sessionId: 'test-session-id',
-    }));
     vi.stubEnv('SANDBOX', 'gemini-test');
   });
 
@@ -48,9 +57,6 @@ describe('bugCommand', () => {
         config: {
           getModel: () => 'gemini-pro',
           getBugCommand: () => undefined,
-          getIdeClient: () => ({
-            getDetectedIdeDisplayName: () => 'VSCode',
-          }),
           getIdeMode: () => true,
         },
       },
@@ -84,9 +90,6 @@ describe('bugCommand', () => {
         config: {
           getModel: () => 'gemini-pro',
           getBugCommand: () => ({ urlTemplate: customTemplate }),
-          getIdeClient: () => ({
-            getDetectedIdeDisplayName: () => 'VSCode',
-          }),
           getIdeMode: () => true,
         },
       },

packages/cli/src/ui/commands/bugCommand.ts

@@ -15,7 +15,7 @@ import { MessageType } from '../types.js';
 import { GIT_COMMIT_INFO } from '../../generated/git-commit.js';
 import { formatMemoryUsage } from '../utils/formatters.js';
 import { getCliVersion } from '../../utils/version.js';
-import { sessionId } from '@google/gemini-cli-core';
+import { IdeClient, sessionId } from '@google/gemini-cli-core';
 
 export const bugCommand: SlashCommand = {
   name: 'bug',
@@ -37,10 +37,7 @@ export const bugCommand: SlashCommand = {
     const modelVersion = config?.getModel() || 'Unknown';
     const cliVersion = await getCliVersion();
     const memoryUsage = formatMemoryUsage(process.memoryUsage().rss);
-    const ideClient =
-      (context.services.config?.getIdeMode() &&
-        context.services.config?.getIdeClient()?.getDetectedIdeDisplayName()) ||
-      '';
+    const ideClient = await getIdeClientName(context);
 
     let info = `
 * **CLI Version:** ${cliVersion}
@@ -90,3 +87,11 @@ export const bugCommand: SlashCommand = {
     }
   },
 };
+
+async function getIdeClientName(context: CommandContext) {
+  if (!context.services.config?.getIdeMode()) {
+    return '';
+  }
+  const ideClient = await IdeClient.getInstance();
+  return ideClient.getDetectedIdeDisplayName() ?? '';
+}

packages/cli/src/ui/commands/ideCommand.test.ts

@@ -8,26 +8,43 @@ import type { MockInstance } from 'vitest';
 import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { ideCommand } from './ideCommand.js';
 import { type CommandContext } from './types.js';
-import { type Config, DetectedIde } from '@google/gemini-cli-core';
+import { DetectedIde } from '@google/gemini-cli-core';
 import * as core from '@google/gemini-cli-core';
 
-vi.mock('child_process');
-vi.mock('glob');
 vi.mock('@google/gemini-cli-core', async (importOriginal) => {
   const original = await importOriginal<typeof core>();
   return {
     ...original,
     getOauthClient: vi.fn(original.getOauthClient),
     getIdeInstaller: vi.fn(original.getIdeInstaller),
+    IdeClient: {
+      getInstance: vi.fn(),
+    },
+    ideContext: {
+      getIdeContext: vi.fn(),
+    },
   };
 });
 
 describe('ideCommand', () => {
   let mockContext: CommandContext;
-  let mockConfig: Config;
+  let mockIdeClient: core.IdeClient;
   let platformSpy: MockInstance;
 
   beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockIdeClient = {
+      reconnect: vi.fn(),
+      disconnect: vi.fn(),
+      connect: vi.fn(),
+      getCurrentIde: vi.fn(),
+      getDetectedIdeDisplayName: vi.fn(),
+      getConnectionStatus: vi.fn(),
+    } as unknown as core.IdeClient;
+
+    vi.mocked(core.IdeClient.getInstance).mockResolvedValue(mockIdeClient);
+
     mockContext = {
       ui: {
         addItem: vi.fn(),
@@ -36,22 +53,14 @@ describe('ideCommand', () => {
         settings: {
           setValue: vi.fn(),
         },
+        config: {
+          getIdeMode: vi.fn(),
+          setIdeMode: vi.fn(),
+          getUsageStatisticsEnabled: vi.fn().mockReturnValue(false),
+        },
       },
     } as unknown as CommandContext;
 
-    mockConfig = {
-      getIdeMode: vi.fn(),
-      getIdeClient: vi.fn(() => ({
-        reconnect: vi.fn(),
-        disconnect: vi.fn(),
-        getCurrentIde: vi.fn(),
-        getDetectedIdeDisplayName: vi.fn(),
-        getConnectionStatus: vi.fn(),
-      })),
-      setIdeModeAndSyncConnection: vi.fn(),
-      setIdeMode: vi.fn(),
-    } as unknown as Config;
-
     platformSpy = vi.spyOn(process, 'platform', 'get');
   });
 
@@ -59,64 +68,57 @@ describe('ideCommand', () => {
     vi.restoreAllMocks();
   });
 
-  it('should return null if config is not provided', () => {
-    const command = ideCommand(null);
-    expect(command).toBeNull();
+  it('should return the ide command', async () => {
+    vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(DetectedIde.VSCode);
+    vi.mocked(mockIdeClient.getDetectedIdeDisplayName).mockReturnValue(
+      'VS Code',
+    );
+    vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+      status: core.IDEConnectionStatus.Disconnected,
+    });
+    const command = await ideCommand();
+    expect(command).not.toBeNull();
+    expect(command.name).toBe('ide');
+    expect(command.subCommands).toHaveLength(3);
+    expect(command.subCommands?.[0].name).toBe('enable');
+    expect(command.subCommands?.[1].name).toBe('status');
+    expect(command.subCommands?.[2].name).toBe('install');
   });
 
-  it('should return the ide command', () => {
-    vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-    vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-      getCurrentIde: () => DetectedIde.VSCode,
-      getDetectedIdeDisplayName: () => 'VS Code',
-      getConnectionStatus: () => ({
-        status: core.IDEConnectionStatus.Disconnected,
-      }),
-    } as ReturnType<Config['getIdeClient']>);
-    const command = ideCommand(mockConfig);
+  it('should show disable command when connected', async () => {
+    vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(DetectedIde.VSCode);
+    vi.mocked(mockIdeClient.getDetectedIdeDisplayName).mockReturnValue(
+      'VS Code',
+    );
+    vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+      status: core.IDEConnectionStatus.Connected,
+    });
+    const command = await ideCommand();
     expect(command).not.toBeNull();
-    expect(command?.name).toBe('ide');
-    expect(command?.subCommands).toHaveLength(3);
-    expect(command?.subCommands?.[0].name).toBe('enable');
-    expect(command?.subCommands?.[1].name).toBe('status');
-    expect(command?.subCommands?.[2].name).toBe('install');
-  });
-
-  it('should show disable command when connected', () => {
-    vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-    vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-      getCurrentIde: () => DetectedIde.VSCode,
-      getDetectedIdeDisplayName: () => 'VS Code',
-      getConnectionStatus: () => ({
-        status: core.IDEConnectionStatus.Connected,
-      }),
-    } as ReturnType<Config['getIdeClient']>);
-    const command = ideCommand(mockConfig);
-    expect(command).not.toBeNull();
-    const subCommandNames = command?.subCommands?.map((cmd) => cmd.name);
+    const subCommandNames = command.subCommands?.map((cmd) => cmd.name);
     expect(subCommandNames).toContain('disable');
     expect(subCommandNames).not.toContain('enable');
   });
 
   describe('status subcommand', () => {
-    const mockGetConnectionStatus = vi.fn();
     beforeEach(() => {
-      vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-        getConnectionStatus: mockGetConnectionStatus,
-        getCurrentIde: () => DetectedIde.VSCode,
-        getDetectedIdeDisplayName: () => 'VS Code',
-      } as unknown as ReturnType<Config['getIdeClient']>);
+      vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+        DetectedIde.VSCode,
+      );
+      vi.mocked(mockIdeClient.getDetectedIdeDisplayName).mockReturnValue(
+        'VS Code',
+      );
     });
 
     it('should show connected status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
         status: core.IDEConnectionStatus.Connected,
       });
-      const command = ideCommand(mockConfig);
+      const command = await ideCommand();
       const result = await command!.subCommands!.find(
         (c) => c.name === 'status',
       )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
         messageType: 'info',
@@ -125,14 +127,14 @@ describe('ideCommand', () => {
     });
 
     it('should show connecting status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
         status: core.IDEConnectionStatus.Connecting,
       });
-      const command = ideCommand(mockConfig);
+      const command = await ideCommand();
       const result = await command!.subCommands!.find(
         (c) => c.name === 'status',
       )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
         messageType: 'info',
@@ -140,14 +142,14 @@ describe('ideCommand', () => {
       });
     });
     it('should show disconnected status', async () => {
-      mockGetConnectionStatus.mockReturnValue({
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
         status: core.IDEConnectionStatus.Disconnected,
       });
-      const command = ideCommand(mockConfig);
+      const command = await ideCommand();
       const result = await command!.subCommands!.find(
         (c) => c.name === 'status',
       )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
         messageType: 'error',
@@ -157,15 +159,15 @@ describe('ideCommand', () => {
 
     it('should show disconnected status with details', async () => {
       const details = 'Something went wrong';
-      mockGetConnectionStatus.mockReturnValue({
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
         status: core.IDEConnectionStatus.Disconnected,
         details,
       });
-      const command = ideCommand(mockConfig);
+      const command = await ideCommand();
       const result = await command!.subCommands!.find(
         (c) => c.name === 'status',
       )!.action!(mockContext, '');
-      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(vi.mocked(mockIdeClient.getConnectionStatus)).toHaveBeenCalled();
       expect(result).toEqual({
         type: 'message',
         messageType: 'error',
@@ -177,32 +179,40 @@ describe('ideCommand', () => {
   describe('install subcommand', () => {
     const mockInstall = vi.fn();
     beforeEach(() => {
-      vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
-      vi.mocked(mockConfig.getIdeClient).mockReturnValue({
-        getCurrentIde: () => DetectedIde.VSCode,
-        getConnectionStatus: () => ({
-          status: core.IDEConnectionStatus.Disconnected,
-        }),
-        getDetectedIdeDisplayName: () => 'VS Code',
-      } as unknown as ReturnType<Config['getIdeClient']>);
+      vi.mocked(mockIdeClient.getCurrentIde).mockReturnValue(
+        DetectedIde.VSCode,
+      );
+      vi.mocked(mockIdeClient.getDetectedIdeDisplayName).mockReturnValue(
+        'VS Code',
+      );
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+      });
       vi.mocked(core.getIdeInstaller).mockReturnValue({
         install: mockInstall,
-        isInstalled: vi.fn(),
       });
       platformSpy.mockReturnValue('linux');
     });
 
     it('should install the extension', async () => {
+      vi.useFakeTimers();
       mockInstall.mockResolvedValue({
         success: true,
         message: 'Successfully installed.',
       });
 
-      const command = ideCommand(mockConfig);
-      await command!.subCommands!.find((c) => c.name === 'install')!.action!(
-        mockContext,
-        '',
-      );
+      const command = await ideCommand();
+
+      // For the polling loop inside the action.
+      vi.mocked(mockIdeClient.getConnectionStatus).mockReturnValue({
+        status: core.IDEConnectionStatus.Connected,
+      });
+
+      const actionPromise = command!.subCommands!.find(
+        (c) => c.name === 'install',
+      )!.action!(mockContext, '');
+      await vi.runAllTimersAsync();
+      await actionPromise;
 
       expect(core.getIdeInstaller).toHaveBeenCalledWith('vscode');
       expect(mockInstall).toHaveBeenCalled();
@@ -220,6 +230,14 @@ describe('ideCommand', () => {
         }),
         expect.any(Number),
       );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: '🟢 Connected to VS Code',
+        }),
+        expect.any(Number),
+      );
+      vi.useRealTimers();
     }, 10000);
 
     it('should show an error if installation fails', async () => {
@@ -228,7 +246,7 @@ describe('ideCommand', () => {
         message: 'Installation failed.',
       });
 
-      const command = ideCommand(mockConfig);
+      const command = await ideCommand();
       await command!.subCommands!.find((c) => c.name === 'install')!.action!(
         mockContext,
         '',

packages/cli/src/ui/commands/ideCommand.ts

@@ -4,7 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Config, IdeClient, File } from '@google/gemini-cli-core';
+import {
+  type Config,
+  IdeClient,
+  type File,
+  logIdeConnection,
+  IdeConnectionEvent,
+  IdeConnectionType,
+} from '@google/gemini-cli-core';
 import {
   getIdeInstaller,
   IDEConnectionStatus,
@@ -111,11 +118,22 @@ async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
   }
 }
 
-export const ideCommand = (config: Config | null): SlashCommand | null => {
-  if (!config) {
-    return null;
+async function setIdeModeAndSyncConnection(
+  config: Config,
+  value: boolean,
+): Promise<void> {
+  config.setIdeMode(value);
+  const ideClient = await IdeClient.getInstance();
+  if (value) {
+    await ideClient.connect();
+    logIdeConnection(config, new IdeConnectionEvent(IdeConnectionType.SESSION));
+  } else {
+    await ideClient.disconnect();
   }
-  const ideClient = config.getIdeClient();
+}
+
+export const ideCommand = async (): Promise<SlashCommand> => {
+  const ideClient = await IdeClient.getInstance();
   const currentIDE = ideClient.getCurrentIde();
   if (!currentIDE || !ideClient.getDetectedIdeDisplayName()) {
     return {
@@ -194,7 +212,7 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
         );
         // Poll for up to 5 seconds for the extension to activate.
         for (let i = 0; i < 10; i++) {
-          await config.setIdeModeAndSyncConnection(true);
+          await setIdeModeAndSyncConnection(context.services.config!, true);
           if (
             ideClient.getConnectionStatus().status ===
             IDEConnectionStatus.Connected
@@ -236,7 +254,7 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
         'ide.enabled',
         true,
       );
-      await config.setIdeModeAndSyncConnection(true);
+      await setIdeModeAndSyncConnection(context.services.config!, true);
       const { messageType, content } = getIdeStatusMessage(ideClient);
       context.ui.addItem(
         {
@@ -258,7 +276,7 @@ export const ideCommand = (config: Config | null): SlashCommand | null => {
         'ide.enabled',
         false,
       );
-      await config.setIdeModeAndSyncConnection(false);
+      await setIdeModeAndSyncConnection(context.services.config!, false);
       const { messageType, content } = getIdeStatusMessage(ideClient);
       context.ui.addItem(
         {

packages/cli/src/ui/components/messages/ToolConfirmationMessage.tsx

@@ -15,7 +15,7 @@ import type {
   ToolMcpConfirmationDetails,
   Config,
 } from '@google/gemini-cli-core';
-import { ToolConfirmationOutcome } from '@google/gemini-cli-core';
+import { IdeClient, ToolConfirmationOutcome } from '@google/gemini-cli-core';
 import type { RadioSelectItem } from '../shared/RadioButtonSelect.js';
 import { RadioButtonSelect } from '../shared/RadioButtonSelect.js';
 import { MaxSizedBox } from '../shared/MaxSizedBox.js';
@@ -43,10 +43,10 @@ export const ToolConfirmationMessage: React.FC<
 
   const handleConfirm = async (outcome: ToolConfirmationOutcome) => {
     if (confirmationDetails.type === 'edit') {
-      const ideClient = config.getIdeClient();
       if (config.getIdeMode()) {
         const cliOutcome =
           outcome === ToolConfirmationOutcome.Cancel ? 'rejected' : 'accepted';
+        const ideClient = await IdeClient.getInstance();
         await ideClient?.resolveDiffFromCli(
           confirmationDetails.filePath,
           cliOutcome,

packages/cli/src/ui/hooks/slashCommandProcessor.test.ts

@@ -86,8 +86,6 @@ import {
   SlashCommandStatus,
   ToolConfirmationOutcome,
   makeFakeConfig,
-  ToolConfirmationOutcome,
-  type IdeClient,
 } from '@google/gemini-cli-core';
 
 function createTestCommand(
@@ -111,11 +109,6 @@ describe('useSlashCommandProcessor', () => {
   const mockSetQuittingMessages = vi.fn();
 
   const mockConfig = makeFakeConfig({});
-  vi.spyOn(mockConfig, 'getIdeClient').mockReturnValue({
-    addStatusChangeListener: vi.fn(),
-    removeStatusChangeListener: vi.fn(),
-  } as unknown as IdeClient);
-
   const mockSettings = {} as LoadedSettings;
 
   beforeEach(() => {

packages/cli/src/ui/hooks/slashCommandProcessor.ts

@@ -17,6 +17,7 @@ import {
   SlashCommandStatus,
   ToolConfirmationOutcome,
   Storage,
+  IdeClient,
 } from '@google/gemini-cli-core';
 import { useSessionStats } from '../contexts/SessionContext.js';
 import { runExitCleanup } from '../../utils/cleanup.js';
@@ -215,15 +216,20 @@ export const useSlashCommandProcessor = (
       return;
     }
 
-    const ideClient = config.getIdeClient();
     const listener = () => {
       reloadCommands();
     };
 
-    ideClient.addStatusChangeListener(listener);
+    (async () => {
+      const ideClient = await IdeClient.getInstance();
+      ideClient.addStatusChangeListener(listener);
+    })();
 
     return () => {
-      ideClient.removeStatusChangeListener(listener);
+      (async () => {
+        const ideClient = await IdeClient.getInstance();
+        ideClient.removeStatusChangeListener(listener);
+      })();
     };
   }, [config, reloadCommands]);
 

packages/cli/src/ui/hooks/useIdeTrustListener.ts

@@ -5,25 +5,26 @@
  */
 
 import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
-import type { Config } from '@google/gemini-cli-core';
-import { ideContext } from '@google/gemini-cli-core';
+import { IdeClient, ideContext } from '@google/gemini-cli-core';
 
 /**
  * This hook listens for trust status updates from the IDE companion extension.
  * It provides the current trust status from the IDE and a flag indicating
  * if a restart is needed because the trust state has changed.
  */
-export function useIdeTrustListener(config: Config) {
-  const subscribe = useCallback(
-    (onStoreChange: () => void) => {
-      const ideClient = config.getIdeClient();
+export function useIdeTrustListener() {
+  const subscribe = useCallback((onStoreChange: () => void) => {
+    (async () => {
+      const ideClient = await IdeClient.getInstance();
       ideClient.addTrustChangeListener(onStoreChange);
-      return () => {
+    })();
+    return () => {
+      (async () => {
+        const ideClient = await IdeClient.getInstance();
         ideClient.removeTrustChangeListener(onStoreChange);
-      };
-    },
-    [config],
-  );
+      })();
+    };
+  }, []);
 
   const getSnapshot = () =>
     ideContext.getIdeContext()?.workspaceState?.isTrusted;