Add files using upload-large-folder tool

projects/ui/qwen-code/packages/cli/src/ui/commands/helpCommand.test.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { helpCommand } from './helpCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import { CommandKind } from './types.js';
+
+describe('helpCommand', () => {
+  let mockContext: CommandContext;
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext({
+      ui: {
+        addItem: vi.fn(),
+      },
+    } as unknown as CommandContext);
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+    vi.clearAllMocks();
+  });
+
+  it('should add a help message to the UI history', async () => {
+    if (!helpCommand.action) {
+      throw new Error('Help command has no action');
+    }
+
+    await helpCommand.action(mockContext, '');
+
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MessageType.HELP,
+        timestamp: expect.any(Date),
+      }),
+      expect.any(Number),
+    );
+  });
+
+  it('should have the correct command properties', () => {
+    expect(helpCommand.name).toBe('help');
+    expect(helpCommand.kind).toBe(CommandKind.BUILT_IN);
+    expect(helpCommand.description).toBe('for help on Qwen Code');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/helpCommand.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, SlashCommand } from './types.js';
+import { MessageType, type HistoryItemHelp } from '../types.js';
+
+export const helpCommand: SlashCommand = {
+  name: 'help',
+  altNames: ['?'],
+  kind: CommandKind.BUILT_IN,
+  description: 'for help on Qwen Code',
+  action: async (context) => {
+    const helpItem: Omit<HistoryItemHelp, 'id'> = {
+      type: MessageType.HELP,
+      timestamp: new Date(),
+    };
+
+    context.ui.addItem(helpItem, Date.now());
+  },
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/ideCommand.test.ts

@@ -0,0 +1,255 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  MockInstance,
+  vi,
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+} from 'vitest';
+import { ideCommand } from './ideCommand.js';
+import { type CommandContext } from './types.js';
+import { type Config, DetectedIde } from '@qwen-code/qwen-code-core';
+import * as core from '@qwen-code/qwen-code-core';
+
+vi.mock('child_process');
+vi.mock('glob');
+vi.mock('@qwen-code/qwen-code-core');
+
+describe('ideCommand', () => {
+  let mockContext: CommandContext;
+  let mockConfig: Config;
+  let platformSpy: MockInstance;
+
+  beforeEach(() => {
+    mockContext = {
+      ui: {
+        addItem: vi.fn(),
+      },
+      services: {
+        settings: {
+          setValue: vi.fn(),
+        },
+      },
+    } 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');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return null if config is not provided', () => {
+    const command = ideCommand(null);
+    expect(command).toBeNull();
+  });
+
+  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);
+    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);
+    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']>);
+    });
+
+    it('should show connected status', async () => {
+      mockGetConnectionStatus.mockReturnValue({
+        status: core.IDEConnectionStatus.Connected,
+      });
+      const command = ideCommand(mockConfig);
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: '🟢 Connected to VS Code',
+      });
+    });
+
+    it('should show connecting status', async () => {
+      mockGetConnectionStatus.mockReturnValue({
+        status: core.IDEConnectionStatus.Connecting,
+      });
+      const command = ideCommand(mockConfig);
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      });
+    });
+    it('should show disconnected status', async () => {
+      mockGetConnectionStatus.mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+      });
+      const command = ideCommand(mockConfig);
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `🔴 Disconnected`,
+      });
+    });
+
+    it('should show disconnected status with details', async () => {
+      const details = 'Something went wrong';
+      mockGetConnectionStatus.mockReturnValue({
+        status: core.IDEConnectionStatus.Disconnected,
+        details,
+      });
+      const command = ideCommand(mockConfig);
+      const result = await command!.subCommands!.find(
+        (c) => c.name === 'status',
+      )!.action!(mockContext, '');
+      expect(mockGetConnectionStatus).toHaveBeenCalled();
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: `🔴 Disconnected: ${details}`,
+      });
+    });
+  });
+
+  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(core.getIdeInstaller).mockReturnValue({
+        install: mockInstall,
+        isInstalled: vi.fn(),
+      });
+      platformSpy.mockReturnValue('linux');
+    });
+
+    it('should install the extension', async () => {
+      mockInstall.mockResolvedValue({
+        success: true,
+        message: 'Successfully installed.',
+      });
+
+      const command = ideCommand(mockConfig);
+      await command!.subCommands!.find((c) => c.name === 'install')!.action!(
+        mockContext,
+        '',
+      );
+
+      expect(core.getIdeInstaller).toHaveBeenCalledWith('vscode');
+      expect(mockInstall).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: `Installing IDE companion...`,
+        }),
+        expect.any(Number),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: 'Successfully installed.',
+        }),
+        expect.any(Number),
+      );
+    }, 10000);
+
+    it('should show an error if installation fails', async () => {
+      mockInstall.mockResolvedValue({
+        success: false,
+        message: 'Installation failed.',
+      });
+
+      const command = ideCommand(mockConfig);
+      await command!.subCommands!.find((c) => c.name === 'install')!.action!(
+        mockContext,
+        '',
+      );
+
+      expect(core.getIdeInstaller).toHaveBeenCalledWith('vscode');
+      expect(mockInstall).toHaveBeenCalled();
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'info',
+          text: `Installing IDE companion...`,
+        }),
+        expect.any(Number),
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'error',
+          text: 'Installation failed.',
+        }),
+        expect.any(Number),
+      );
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/ideCommand.ts

@@ -0,0 +1,283 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Config,
+  DetectedIde,
+  QWEN_CODE_COMPANION_EXTENSION_NAME,
+  IDEConnectionStatus,
+  getIdeInfo,
+  getIdeInstaller,
+  IdeClient,
+  type File,
+  ideContext,
+} from '@qwen-code/qwen-code-core';
+import path from 'node:path';
+import {
+  CommandContext,
+  SlashCommand,
+  SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import { SettingScope } from '../../config/settings.js';
+
+function getIdeStatusMessage(ideClient: IdeClient): {
+  messageType: 'info' | 'error';
+  content: string;
+} {
+  const connection = ideClient.getConnectionStatus();
+  switch (connection.status) {
+    case IDEConnectionStatus.Connected:
+      return {
+        messageType: 'info',
+        content: `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`,
+      };
+    case IDEConnectionStatus.Connecting:
+      return {
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      };
+    default: {
+      let content = `🔴 Disconnected`;
+      if (connection?.details) {
+        content += `: ${connection.details}`;
+      }
+      return {
+        messageType: 'error',
+        content,
+      };
+    }
+  }
+}
+
+function formatFileList(openFiles: File[]): string {
+  const basenameCounts = new Map<string, number>();
+  for (const file of openFiles) {
+    const basename = path.basename(file.path);
+    basenameCounts.set(basename, (basenameCounts.get(basename) || 0) + 1);
+  }
+
+  const fileList = openFiles
+    .map((file: File) => {
+      const basename = path.basename(file.path);
+      const isDuplicate = (basenameCounts.get(basename) || 0) > 1;
+      const parentDir = path.basename(path.dirname(file.path));
+      const displayName = isDuplicate
+        ? `${basename} (/${parentDir})`
+        : basename;
+
+      return `  - ${displayName}${file.isActive ? ' (active)' : ''}`;
+    })
+    .join('\n');
+
+  const infoMessage = `
+(Note: The file list is limited to a number of recently accessed files within your workspace and only includes local files on disk)`;
+
+  return `\n\nOpen files:\n${fileList}\n${infoMessage}`;
+}
+
+async function getIdeStatusMessageWithFiles(ideClient: IdeClient): Promise<{
+  messageType: 'info' | 'error';
+  content: string;
+}> {
+  const connection = ideClient.getConnectionStatus();
+  switch (connection.status) {
+    case IDEConnectionStatus.Connected: {
+      let content = `🟢 Connected to ${ideClient.getDetectedIdeDisplayName()}`;
+      const context = ideContext.getIdeContext();
+      const openFiles = context?.workspaceState?.openFiles;
+      if (openFiles && openFiles.length > 0) {
+        content += formatFileList(openFiles);
+      }
+      return {
+        messageType: 'info',
+        content,
+      };
+    }
+    case IDEConnectionStatus.Connecting:
+      return {
+        messageType: 'info',
+        content: `🟡 Connecting...`,
+      };
+    default: {
+      let content = `🔴 Disconnected`;
+      if (connection?.details) {
+        content += `: ${connection.details}`;
+      }
+      return {
+        messageType: 'error',
+        content,
+      };
+    }
+  }
+}
+
+export const ideCommand = (config: Config | null): SlashCommand | null => {
+  if (!config) {
+    return null;
+  }
+  const ideClient = config.getIdeClient();
+  const currentIDE = ideClient.getCurrentIde();
+  if (!currentIDE || !ideClient.getDetectedIdeDisplayName()) {
+    return {
+      name: 'ide',
+      description: 'manage IDE integration',
+      kind: CommandKind.BUILT_IN,
+      action: (): SlashCommandActionReturn =>
+        ({
+          type: 'message',
+          messageType: 'error',
+          content: `IDE integration is not supported in your current environment. To use this feature, run Qwen Code in one of these supported IDEs: ${Object.values(
+            DetectedIde,
+          )
+            .map((ide) => getIdeInfo(ide).displayName)
+            .join(', ')}`,
+        }) as const,
+    };
+  }
+
+  const ideSlashCommand: SlashCommand = {
+    name: 'ide',
+    description: 'manage IDE integration',
+    kind: CommandKind.BUILT_IN,
+    subCommands: [],
+  };
+
+  const statusCommand: SlashCommand = {
+    name: 'status',
+    description: 'check status of IDE integration',
+    kind: CommandKind.BUILT_IN,
+    action: async (): Promise<SlashCommandActionReturn> => {
+      const { messageType, content } =
+        await getIdeStatusMessageWithFiles(ideClient);
+      return {
+        type: 'message',
+        messageType,
+        content,
+      } as const;
+    },
+  };
+
+  const installCommand: SlashCommand = {
+    name: 'install',
+    description: `install required IDE companion for ${ideClient.getDetectedIdeDisplayName()}`,
+    kind: CommandKind.BUILT_IN,
+    action: async (context) => {
+      const installer = getIdeInstaller(currentIDE);
+      if (!installer) {
+        context.ui.addItem(
+          {
+            type: 'error',
+            text: `No installer is available for ${ideClient.getDetectedIdeDisplayName()}. Please install the '${QWEN_CODE_COMPANION_EXTENSION_NAME}' extension manually from the marketplace.`,
+          },
+          Date.now(),
+        );
+        return;
+      }
+
+      context.ui.addItem(
+        {
+          type: 'info',
+          text: `Installing IDE companion...`,
+        },
+        Date.now(),
+      );
+
+      const result = await installer.install();
+      context.ui.addItem(
+        {
+          type: result.success ? 'info' : 'error',
+          text: result.message,
+        },
+        Date.now(),
+      );
+      if (result.success) {
+        context.services.settings.setValue(SettingScope.User, 'ideMode', true);
+        // Poll for up to 5 seconds for the extension to activate.
+        for (let i = 0; i < 10; i++) {
+          await config.setIdeModeAndSyncConnection(true);
+          if (
+            ideClient.getConnectionStatus().status ===
+            IDEConnectionStatus.Connected
+          ) {
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+
+        const { messageType, content } = getIdeStatusMessage(ideClient);
+        if (messageType === 'error') {
+          context.ui.addItem(
+            {
+              type: messageType,
+              text: `Failed to automatically enable IDE integration. To fix this, run the CLI in a new terminal window.`,
+            },
+            Date.now(),
+          );
+        } else {
+          context.ui.addItem(
+            {
+              type: messageType,
+              text: content,
+            },
+            Date.now(),
+          );
+        }
+      }
+    },
+  };
+
+  const enableCommand: SlashCommand = {
+    name: 'enable',
+    description: 'enable IDE integration',
+    kind: CommandKind.BUILT_IN,
+    action: async (context: CommandContext) => {
+      context.services.settings.setValue(SettingScope.User, 'ideMode', true);
+      await config.setIdeModeAndSyncConnection(true);
+      const { messageType, content } = getIdeStatusMessage(ideClient);
+      context.ui.addItem(
+        {
+          type: messageType,
+          text: content,
+        },
+        Date.now(),
+      );
+    },
+  };
+
+  const disableCommand: SlashCommand = {
+    name: 'disable',
+    description: 'disable IDE integration',
+    kind: CommandKind.BUILT_IN,
+    action: async (context: CommandContext) => {
+      context.services.settings.setValue(SettingScope.User, 'ideMode', false);
+      await config.setIdeModeAndSyncConnection(false);
+      const { messageType, content } = getIdeStatusMessage(ideClient);
+      context.ui.addItem(
+        {
+          type: messageType,
+          text: content,
+        },
+        Date.now(),
+      );
+    },
+  };
+
+  const { status } = ideClient.getConnectionStatus();
+  const isConnected = status === IDEConnectionStatus.Connected;
+
+  if (isConnected) {
+    ideSlashCommand.subCommands = [statusCommand, disableCommand];
+  } else {
+    ideSlashCommand.subCommands = [
+      enableCommand,
+      statusCommand,
+      installCommand,
+    ];
+  }
+
+  return ideSlashCommand;
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/initCommand.test.ts

@@ -0,0 +1,127 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { initCommand } from './initCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { type CommandContext } from './types.js';
+
+// Mock the 'fs' module with both named and default exports to avoid breaking default import sites
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>();
+  const existsSync = vi.fn();
+  const writeFileSync = vi.fn();
+  const readFileSync = vi.fn();
+  return {
+    ...actual,
+    existsSync,
+    writeFileSync,
+    readFileSync,
+    default: {
+      ...(actual as unknown as Record<string, unknown>),
+      existsSync,
+      writeFileSync,
+      readFileSync,
+    },
+  } as unknown as typeof import('fs');
+});
+
+describe('initCommand', () => {
+  let mockContext: CommandContext;
+  const targetDir = '/test/dir';
+  const DEFAULT_CONTEXT_FILENAME = 'QWEN.md';
+  const geminiMdPath = path.join(targetDir, DEFAULT_CONTEXT_FILENAME);
+
+  beforeEach(() => {
+    // Create a fresh mock context for each test
+    mockContext = createMockCommandContext({
+      services: {
+        config: {
+          getTargetDir: () => targetDir,
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    // Clear all mocks after each test
+    vi.clearAllMocks();
+  });
+
+  it(`should inform the user if ${DEFAULT_CONTEXT_FILENAME} already exists and is non-empty`, async () => {
+    // Arrange: Simulate that the file exists
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.spyOn(fs, 'readFileSync').mockReturnValue('# Existing content');
+
+    // Act: Run the command's action
+    const result = await initCommand.action!(mockContext, '');
+
+    // Assert: Check for the correct informational message
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'info',
+      content: `A ${DEFAULT_CONTEXT_FILENAME} file already exists in this directory. No changes were made.`,
+    });
+    // Assert: Ensure no file was written
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+  });
+
+  it(`should create ${DEFAULT_CONTEXT_FILENAME} and submit a prompt if it does not exist`, async () => {
+    // Arrange: Simulate that the file does not exist
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    // Act: Run the command's action
+    const result = await initCommand.action!(mockContext, '');
+
+    // Assert: Check that writeFileSync was called correctly
+    expect(fs.writeFileSync).toHaveBeenCalledWith(geminiMdPath, '', 'utf8');
+
+    // Assert: Check that an informational message was added to the UI
+    expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+      {
+        type: 'info',
+        text: `Empty ${DEFAULT_CONTEXT_FILENAME} created. Now analyzing the project to populate it.`,
+      },
+      expect.any(Number),
+    );
+
+    // Assert: Check that the correct prompt is submitted
+    expect(result.type).toBe('submit_prompt');
+    expect(result.content).toContain(
+      'You are Qwen Code, an interactive CLI agent',
+    );
+  });
+
+  it(`should proceed to initialize when ${DEFAULT_CONTEXT_FILENAME} exists but is empty`, async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.spyOn(fs, 'readFileSync').mockReturnValue('   \n  ');
+
+    const result = await initCommand.action!(mockContext, '');
+
+    expect(fs.writeFileSync).toHaveBeenCalledWith(geminiMdPath, '', 'utf8');
+    expect(result.type).toBe('submit_prompt');
+  });
+
+  it('should return an error if config is not available', async () => {
+    // Arrange: Create a context without config
+    const noConfigContext = createMockCommandContext();
+    if (noConfigContext.services) {
+      noConfigContext.services.config = null;
+    }
+
+    // Act: Run the command's action
+    const result = await initCommand.action!(noConfigContext, '');
+
+    // Assert: Check for the correct error message
+    expect(result).toEqual({
+      type: 'message',
+      messageType: 'error',
+      content: 'Configuration not available.',
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/initCommand.ts

@@ -0,0 +1,117 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  CommandContext,
+  SlashCommand,
+  SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import { getCurrentGeminiMdFilename } from '@qwen-code/qwen-code-core';
+
+export const initCommand: SlashCommand = {
+  name: 'init',
+  description: 'Analyzes the project and creates a tailored QWEN.md file.',
+  kind: CommandKind.BUILT_IN,
+  action: async (
+    context: CommandContext,
+    _args: string,
+  ): Promise<SlashCommandActionReturn> => {
+    if (!context.services.config) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Configuration not available.',
+      };
+    }
+    const targetDir = context.services.config.getTargetDir();
+    const contextFileName = getCurrentGeminiMdFilename();
+    const contextFilePath = path.join(targetDir, contextFileName);
+
+    try {
+      if (fs.existsSync(contextFilePath)) {
+        // If file exists but is empty (or whitespace), continue to initialize; otherwise, bail out
+        try {
+          const existing = fs.readFileSync(contextFilePath, 'utf8');
+          if (existing && existing.trim().length > 0) {
+            return {
+              type: 'message',
+              messageType: 'info',
+              content: `A ${contextFileName} file already exists in this directory. No changes were made.`,
+            };
+          }
+        } catch {
+          // If we fail to read, conservatively proceed to (re)create the file
+        }
+      }
+
+      // Ensure an empty context file exists before prompting the model to populate it
+      try {
+        fs.writeFileSync(contextFilePath, '', 'utf8');
+        context.ui.addItem(
+          {
+            type: 'info',
+            text: `Empty ${contextFileName} created. Now analyzing the project to populate it.`,
+          },
+          Date.now(),
+        );
+      } catch (err) {
+        return {
+          type: 'message',
+          messageType: 'error',
+          content: `Failed to create ${contextFileName}: ${err instanceof Error ? err.message : String(err)}`,
+        };
+      }
+    } catch (error) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Unexpected error preparing ${contextFileName}: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+
+    return {
+      type: 'submit_prompt',
+      content: `
+You are Qwen Code, an interactive CLI agent. Analyze the current directory and generate a comprehensive ${contextFileName} file to be used as instructional context for future interactions.
+
+**Analysis Process:**
+
+1.  **Initial Exploration:**
+    *   Start by listing the files and directories to get a high-level overview of the structure.
+    *   Read the README file (e.g., \`README.md\`, \`README.txt\`) if it exists. This is often the best place to start.
+
+2.  **Iterative Deep Dive (up to 10 files):**
+    *   Based on your initial findings, select a few files that seem most important (e.g., configuration files, main source files, documentation).
+    *   Read them. As you learn more, refine your understanding and decide which files to read next. You don't need to decide all 10 files at once. Let your discoveries guide your exploration.
+
+3.  **Identify Project Type:**
+    *   **Code Project:** Look for clues like \`package.json\`, \`requirements.txt\`, \`pom.xml\`, \`go.mod\`, \`Cargo.toml\`, \`build.gradle\`, or a \`src\` directory. If you find them, this is likely a software project.
+    *   **Non-Code Project:** If you don't find code-related files, this might be a directory for documentation, research papers, notes, or something else.
+
+**${contextFileName} Content Generation:**
+
+**For a Code Project:**
+
+*   **Project Overview:** Write a clear and concise summary of the project's purpose, main technologies, and architecture.
+*   **Building and Running:** Document the key commands for building, running, and testing the project. Infer these from the files you've read (e.g., \`scripts\` in \`package.json\`, \`Makefile\`, etc.). If you can't find explicit commands, provide a placeholder with a TODO.
+*   **Development Conventions:** Describe any coding styles, testing practices, or contribution guidelines you can infer from the codebase.
+
+**For a Non-Code Project:**
+
+*   **Directory Overview:** Describe the purpose and contents of the directory. What is it for? What kind of information does it hold?
+*   **Key Files:** List the most important files and briefly explain what they contain.
+*   **Usage:** Explain how the contents of this directory are intended to be used.
+
+**Final Output:**
+
+Write the complete content to the \`${contextFileName}\` file. The output must be well-formatted Markdown.
+`,
+    };
+  },
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/mcpCommand.test.ts

@@ -0,0 +1,1057 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { mcpCommand } from './mcpCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import {
+  MCPServerStatus,
+  MCPDiscoveryState,
+  getMCPServerStatus,
+  getMCPDiscoveryState,
+  DiscoveredMCPTool,
+} from '@qwen-code/qwen-code-core';
+
+import { MessageActionReturn } from './types.js';
+import { Type, CallableTool } from '@google/genai';
+
+vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
+  return {
+    ...actual,
+    getMCPServerStatus: vi.fn(),
+    getMCPDiscoveryState: vi.fn(),
+    MCPOAuthProvider: {
+      authenticate: vi.fn(),
+    },
+    MCPOAuthTokenStorage: {
+      getToken: vi.fn(),
+      isTokenExpired: vi.fn(),
+    },
+  };
+});
+
+// Helper function to check if result is a message action
+const isMessageAction = (result: unknown): result is MessageActionReturn =>
+  result !== null &&
+  typeof result === 'object' &&
+  'type' in result &&
+  result.type === 'message';
+
+// Helper function to create a mock DiscoveredMCPTool
+const createMockMCPTool = (
+  name: string,
+  serverName: string,
+  description?: string,
+) =>
+  new DiscoveredMCPTool(
+    {
+      callTool: vi.fn(),
+      tool: vi.fn(),
+    } as unknown as CallableTool,
+    serverName,
+    name,
+    description || `Description for ${name}`,
+    { type: Type.OBJECT, properties: {} },
+    name, // serverToolName same as name for simplicity
+  );
+
+describe('mcpCommand', () => {
+  let mockContext: ReturnType<typeof createMockCommandContext>;
+  let mockConfig: {
+    getToolRegistry: ReturnType<typeof vi.fn>;
+    getMcpServers: ReturnType<typeof vi.fn>;
+    getBlockedMcpServers: ReturnType<typeof vi.fn>;
+    getPromptRegistry: ReturnType<typeof vi.fn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Set up default mock environment
+    vi.unstubAllEnvs();
+
+    // Default mock implementations
+    vi.mocked(getMCPServerStatus).mockReturnValue(MCPServerStatus.CONNECTED);
+    vi.mocked(getMCPDiscoveryState).mockReturnValue(
+      MCPDiscoveryState.COMPLETED,
+    );
+
+    // Create mock config with all necessary methods
+    mockConfig = {
+      getToolRegistry: vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      }),
+      getMcpServers: vi.fn().mockReturnValue({}),
+      getBlockedMcpServers: vi.fn().mockReturnValue([]),
+      getPromptRegistry: vi.fn().mockResolvedValue({
+        getAllPrompts: vi.fn().mockReturnValue([]),
+        getPromptsByServer: vi.fn().mockReturnValue([]),
+      }),
+    };
+
+    mockContext = createMockCommandContext({
+      services: {
+        config: mockConfig,
+      },
+    });
+  });
+
+  describe('basic functionality', () => {
+    it('should show an error if config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const result = await mcpCommand.action!(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should show an error if tool registry is not available', async () => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue(undefined);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not retrieve tool registry.',
+      });
+    });
+  });
+
+  describe('no MCP servers configured', () => {
+    beforeEach(() => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+      mockConfig.getMcpServers = vi.fn().mockReturnValue({});
+    });
+
+    it('should display a message with a URL when no MCP servers are configured', async () => {
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content:
+          'No MCP servers configured. Please view MCP documentation in your browser: https://qwenlm.github.io/qwen-code-docs/en/tools/mcp-server/#how-to-set-up-your-mcp-server or use the cli /docs command',
+      });
+    });
+  });
+
+  describe('with configured MCP servers', () => {
+    beforeEach(() => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+        server3: { command: 'cmd3' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+    });
+
+    it('should display configured MCP servers with status indicators and their tools', async () => {
+      // Setup getMCPServerStatus mock implementation
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.CONNECTED;
+        return MCPServerStatus.DISCONNECTED; // server3
+      });
+
+      // Mock tools from each server using actual DiscoveredMCPTool instances
+      const mockServer1Tools = [
+        createMockMCPTool('server1_tool1', 'server1'),
+        createMockMCPTool('server1_tool2', 'server1'),
+      ];
+      const mockServer2Tools = [createMockMCPTool('server2_tool1', 'server2')];
+      const mockServer3Tools = [createMockMCPTool('server3_tool1', 'server3')];
+
+      const allTools = [
+        ...mockServer1Tools,
+        ...mockServer2Tools,
+        ...mockServer3Tools,
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(allTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        // Server 1 - Connected
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (2 tools)',
+        );
+        expect(message).toContain('server1_tool1');
+        expect(message).toContain('server1_tool2');
+
+        // Server 2 - Connected
+        expect(message).toContain(
+          '🟢 \u001b[1mserver2\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('server2_tool1');
+
+        // Server 3 - Disconnected but with cached tools, so shows as Ready
+        expect(message).toContain(
+          '🟢 \u001b[1mserver3\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('server3_tool1');
+
+        // Check that helpful tips are displayed when no arguments are provided
+        expect(message).toContain('💡 Tips:');
+        expect(message).toContain('/mcp desc');
+        expect(message).toContain('/mcp schema');
+        expect(message).toContain('/mcp nodesc');
+        expect(message).toContain('Ctrl+T');
+      }
+    });
+
+    it('should display tool descriptions when desc argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Mock tools with descriptions using actual DiscoveredMCPTool instances
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'This is tool 1 description'),
+        createMockMCPTool('tool2', 'server1', 'This is tool 2 description'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'desc');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that server description is included
+        expect(message).toContain(
+          '\u001b[1mserver1\u001b[0m - Ready (2 tools)',
+        );
+        expect(message).toContain(
+          '\u001b[32mThis is a server description\u001b[0m',
+        );
+
+        // Check that tool descriptions are included
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+        expect(message).toContain(
+          '\u001b[32mThis is tool 1 description\u001b[0m',
+        );
+        expect(message).toContain('\u001b[36mtool2\u001b[0m');
+        expect(message).toContain(
+          '\u001b[32mThis is tool 2 description\u001b[0m',
+        );
+
+        // Check that tips are NOT displayed when arguments are provided
+        expect(message).not.toContain('💡 Tips:');
+      }
+    });
+
+    it('should not display descriptions when nodesc argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'This is tool 1 description'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'nodesc');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that descriptions are not included
+        expect(message).not.toContain('This is a server description');
+        expect(message).not.toContain('This is tool 1 description');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+
+        // Check that tips are NOT displayed when arguments are provided
+        expect(message).not.toContain('💡 Tips:');
+      }
+    });
+
+    it('should indicate when a server has no tools', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Setup server statuses
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.DISCONNECTED;
+        return MCPServerStatus.DISCONNECTED;
+      });
+
+      // Mock tools - only server1 has tools
+      const mockServerTools = [createMockMCPTool('server1_tool1', 'server1')];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain('\u001b[36mserver1_tool1\u001b[0m');
+        expect(message).toContain(
+          '🔴 \u001b[1mserver2\u001b[0m - Disconnected (0 tools cached)',
+        );
+        expect(message).toContain('No tools or prompts available');
+      }
+    });
+
+    it('should show startup indicator when servers are connecting', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+        server2: { command: 'cmd2' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Setup server statuses with one connecting
+      vi.mocked(getMCPServerStatus).mockImplementation((serverName) => {
+        if (serverName === 'server1') return MCPServerStatus.CONNECTED;
+        if (serverName === 'server2') return MCPServerStatus.CONNECTING;
+        return MCPServerStatus.DISCONNECTED;
+      });
+
+      // Setup discovery state as in progress
+      vi.mocked(getMCPDiscoveryState).mockReturnValue(
+        MCPDiscoveryState.IN_PROGRESS,
+      );
+
+      // Mock tools
+      const mockServerTools = [
+        createMockMCPTool('server1_tool1', 'server1'),
+        createMockMCPTool('server2_tool1', 'server2'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that startup indicator is shown
+        expect(message).toContain(
+          '⏳ MCP servers are starting up (1 initializing)...',
+        );
+        expect(message).toContain(
+          'Note: First startup may take longer. Tool availability will update automatically.',
+        );
+
+        // Check server statuses
+        expect(message).toContain(
+          '🟢 \u001b[1mserver1\u001b[0m - Ready (1 tool)',
+        );
+        expect(message).toContain(
+          '🔄 \u001b[1mserver2\u001b[0m - Starting... (first startup may take longer) (tools and prompts will appear when ready)',
+        );
+      }
+    });
+
+    it('should display the extension name for servers from extensions', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1', extensionName: 'my-extension' },
+      };
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server1 (from my-extension)');
+      }
+    });
+
+    it('should display blocked MCP servers', async () => {
+      mockConfig.getMcpServers = vi.fn().mockReturnValue({});
+      const blockedServers = [
+        { name: 'blocked-server', extensionName: 'my-extension' },
+      ];
+      mockConfig.getBlockedMcpServers = vi.fn().mockReturnValue(blockedServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain(
+          '🔴 \u001b[1mblocked-server (from my-extension)\u001b[0m - Blocked',
+        );
+      }
+    });
+
+    it('should display both active and blocked servers correctly', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1', extensionName: 'my-extension' },
+      };
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      const blockedServers = [
+        { name: 'blocked-server', extensionName: 'another-extension' },
+      ];
+      mockConfig.getBlockedMcpServers = vi.fn().mockReturnValue(blockedServers);
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server1 (from my-extension)');
+        expect(message).toContain(
+          '🔴 \u001b[1mblocked-server (from another-extension)\u001b[0m - Blocked',
+        );
+      }
+    });
+  });
+
+  describe('schema functionality', () => {
+    it('should display tool schemas when schema argument is used', async () => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'This is a server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Create tools with parameter schemas
+      const mockCallableTool1: CallableTool = {
+        callTool: vi.fn(),
+        tool: vi.fn(),
+      } as unknown as CallableTool;
+      const mockCallableTool2: CallableTool = {
+        callTool: vi.fn(),
+        tool: vi.fn(),
+      } as unknown as CallableTool;
+
+      const tool1 = new DiscoveredMCPTool(
+        mockCallableTool1,
+        'server1',
+        'tool1',
+        'This is tool 1 description',
+        {
+          type: Type.OBJECT,
+          properties: {
+            param1: { type: Type.STRING, description: 'First parameter' },
+          },
+          required: ['param1'],
+        },
+        'tool1',
+      );
+
+      const tool2 = new DiscoveredMCPTool(
+        mockCallableTool2,
+        'server1',
+        'tool2',
+        'This is tool 2 description',
+        {
+          type: Type.OBJECT,
+          properties: {
+            param2: { type: Type.NUMBER, description: 'Second parameter' },
+          },
+          required: ['param2'],
+        },
+        'tool2',
+      );
+
+      const mockServerTools = [tool1, tool2];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+
+        // Check that server description is included
+        expect(message).toContain('Ready (2 tools)');
+        expect(message).toContain('This is a server description');
+
+        // Check that tool descriptions and schemas are included
+        expect(message).toContain('This is tool 1 description');
+        expect(message).toContain('Parameters:');
+        expect(message).toContain('param1');
+        expect(message).toContain('STRING');
+        expect(message).toContain('This is tool 2 description');
+        expect(message).toContain('param2');
+        expect(message).toContain('NUMBER');
+      }
+    });
+
+    it('should handle tools without parameter schemas gracefully', async () => {
+      const mockMcpServers = {
+        server1: { command: 'cmd1' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      // Mock tools without parameter schemas
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'Tool without schema'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('tool1');
+        expect(message).toContain('Tool without schema');
+        // Should not crash when parameterSchema is undefined
+      }
+    });
+  });
+
+  describe('argument parsing', () => {
+    beforeEach(() => {
+      const mockMcpServers = {
+        server1: {
+          command: 'cmd1',
+          description: 'Server description',
+        },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+
+      const mockServerTools = [
+        createMockMCPTool('tool1', 'server1', 'Test tool'),
+      ];
+
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue(mockServerTools),
+      });
+    });
+
+    it('should handle "descriptions" as alias for "desc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'descriptions');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+      }
+    });
+
+    it('should handle "nodescriptions" as alias for "nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'nodescriptions');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle mixed case arguments', async () => {
+      const result = await mcpCommand.action!(mockContext, 'DESC');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+      }
+    });
+
+    it('should handle multiple arguments - "schema desc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema desc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle multiple arguments - "desc schema"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'desc schema');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle "schema" alone showing descriptions', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle "nodesc" overriding "schema" - "schema nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'schema nodesc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('Parameters:'); // Schema should still show
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle "nodesc" overriding "desc" - "desc nodesc"', async () => {
+      const result = await mcpCommand.action!(mockContext, 'desc nodesc');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle "nodesc" overriding both "desc" and "schema" - "desc schema nodesc"', async () => {
+      const result = await mcpCommand.action!(
+        mockContext,
+        'desc schema nodesc',
+      );
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).toContain('Parameters:'); // Schema should still show
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle extra whitespace in arguments', async () => {
+      const result = await mcpCommand.action!(mockContext, '  desc   schema  ');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('Test tool');
+        expect(message).toContain('Server description');
+        expect(message).toContain('Parameters:');
+      }
+    });
+
+    it('should handle empty arguments gracefully', async () => {
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+
+    it('should handle unknown arguments gracefully', async () => {
+      const result = await mcpCommand.action!(mockContext, 'unknown arg');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).not.toContain('Test tool');
+        expect(message).not.toContain('Server description');
+        expect(message).not.toContain('Parameters:');
+        expect(message).toContain('\u001b[36mtool1\u001b[0m');
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty server names gracefully', async () => {
+      const mockMcpServers = {
+        '': { command: 'cmd1' }, // Empty server name
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: expect.stringContaining('Configured MCP servers:'),
+      });
+    });
+
+    it('should handle servers with special characters in names', async () => {
+      const mockMcpServers = {
+        'server-with-dashes': { command: 'cmd1' },
+        server_with_underscores: { command: 'cmd2' },
+        'server.with.dots': { command: 'cmd3' },
+      };
+
+      mockConfig.getMcpServers = vi.fn().mockReturnValue(mockMcpServers);
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue({
+        getAllTools: vi.fn().mockReturnValue([]),
+      });
+
+      const result = await mcpCommand.action!(mockContext, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        const message = result.content;
+        expect(message).toContain('server-with-dashes');
+        expect(message).toContain('server_with_underscores');
+        expect(message).toContain('server.with.dots');
+      }
+    });
+  });
+
+  describe('auth subcommand', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should list OAuth-enabled servers when no server name is provided', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'oauth-server': { oauth: { enabled: true } },
+              'regular-server': {},
+              'another-oauth': { oauth: { enabled: true } },
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      expect(authCommand).toBeDefined();
+
+      const result = await authCommand!.action!(context, '');
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('oauth-server');
+        expect(result.content).toContain('another-oauth');
+        expect(result.content).not.toContain('regular-server');
+        expect(result.content).toContain('/mcp auth <server-name>');
+      }
+    });
+
+    it('should show message when no OAuth servers are configured', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'regular-server': {},
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, '');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toBe(
+          'No MCP servers configured with OAuth authentication.',
+        );
+      }
+    });
+
+    it('should authenticate with a specific server', async () => {
+      const mockToolRegistry = {
+        discoverToolsForServer: vi.fn(),
+      };
+      const mockGeminiClient = {
+        setTools: vi.fn(),
+      };
+
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'test-server': {
+                url: 'http://localhost:3000',
+                oauth: { enabled: true },
+              },
+            }),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            getGeminiClient: vi.fn().mockReturnValue(mockGeminiClient),
+            getPromptRegistry: vi.fn().mockResolvedValue({
+              removePromptsByServer: vi.fn(),
+            }),
+          },
+        },
+      });
+      // Mock the reloadCommands function
+      context.ui.reloadCommands = vi.fn();
+
+      const { MCPOAuthProvider } = await import('@qwen-code/qwen-code-core');
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'test-server');
+
+      expect(MCPOAuthProvider.authenticate).toHaveBeenCalledWith(
+        'test-server',
+        { enabled: true },
+        'http://localhost:3000',
+      );
+      expect(mockToolRegistry.discoverToolsForServer).toHaveBeenCalledWith(
+        'test-server',
+      );
+      expect(mockGeminiClient.setTools).toHaveBeenCalled();
+      expect(context.ui.reloadCommands).toHaveBeenCalledTimes(1);
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('Successfully authenticated');
+      }
+    });
+
+    it('should handle authentication errors', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'test-server': { oauth: { enabled: true } },
+            }),
+          },
+        },
+      });
+
+      const { MCPOAuthProvider } = await import('@qwen-code/qwen-code-core');
+      (
+        MCPOAuthProvider.authenticate as ReturnType<typeof vi.fn>
+      ).mockRejectedValue(new Error('Auth failed'));
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'test-server');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('error');
+        expect(result.content).toContain('Failed to authenticate');
+        expect(result.content).toContain('Auth failed');
+      }
+    });
+
+    it('should handle non-existent server', async () => {
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({
+              'existing-server': {},
+            }),
+          },
+        },
+      });
+
+      const authCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'auth',
+      );
+      const result = await authCommand!.action!(context, 'non-existent');
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('error');
+        expect(result.content).toContain("MCP server 'non-existent' not found");
+      }
+    });
+  });
+
+  describe('refresh subcommand', () => {
+    it('should refresh the list of tools and display the status', async () => {
+      const mockToolRegistry = {
+        discoverMcpTools: vi.fn(),
+        restartMcpServers: vi.fn(),
+        getAllTools: vi.fn().mockReturnValue([]),
+      };
+      const mockGeminiClient = {
+        setTools: vi.fn(),
+      };
+
+      const context = createMockCommandContext({
+        services: {
+          config: {
+            getMcpServers: vi.fn().mockReturnValue({ server1: {} }),
+            getBlockedMcpServers: vi.fn().mockReturnValue([]),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            getGeminiClient: vi.fn().mockReturnValue(mockGeminiClient),
+            getPromptRegistry: vi.fn().mockResolvedValue({
+              getPromptsByServer: vi.fn().mockReturnValue([]),
+            }),
+          },
+        },
+      });
+      // Mock the reloadCommands function, which is new logic.
+      context.ui.reloadCommands = vi.fn();
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      expect(refreshCommand).toBeDefined();
+
+      const result = await refreshCommand!.action!(context, '');
+
+      expect(context.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: 'info',
+          text: 'Restarting MCP servers...',
+        },
+        expect.any(Number),
+      );
+      expect(mockToolRegistry.restartMcpServers).toHaveBeenCalled();
+      expect(mockGeminiClient.setTools).toHaveBeenCalled();
+      expect(context.ui.reloadCommands).toHaveBeenCalledTimes(1);
+
+      expect(isMessageAction(result)).toBe(true);
+      if (isMessageAction(result)) {
+        expect(result.messageType).toBe('info');
+        expect(result.content).toContain('Configured MCP servers:');
+      }
+    });
+
+    it('should show an error if config is not available', async () => {
+      const contextWithoutConfig = createMockCommandContext({
+        services: {
+          config: null,
+        },
+      });
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      const result = await refreshCommand!.action!(contextWithoutConfig, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      });
+    });
+
+    it('should show an error if tool registry is not available', async () => {
+      mockConfig.getToolRegistry = vi.fn().mockReturnValue(undefined);
+
+      const refreshCommand = mcpCommand.subCommands?.find(
+        (cmd) => cmd.name === 'refresh',
+      );
+      const result = await refreshCommand!.action!(mockContext, '');
+
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not retrieve tool registry.',
+      });
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/mcpCommand.ts

@@ -0,0 +1,531 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  SlashCommand,
+  SlashCommandActionReturn,
+  CommandContext,
+  CommandKind,
+  MessageActionReturn,
+} from './types.js';
+import {
+  DiscoveredMCPPrompt,
+  DiscoveredMCPTool,
+  getMCPDiscoveryState,
+  getMCPServerStatus,
+  MCPDiscoveryState,
+  MCPServerStatus,
+  mcpServerRequiresOAuth,
+  getErrorMessage,
+} from '@qwen-code/qwen-code-core';
+
+const COLOR_GREEN = '\u001b[32m';
+const COLOR_YELLOW = '\u001b[33m';
+const COLOR_RED = '\u001b[31m';
+const COLOR_CYAN = '\u001b[36m';
+const COLOR_GREY = '\u001b[90m';
+const RESET_COLOR = '\u001b[0m';
+
+const getMcpStatus = async (
+  context: CommandContext,
+  showDescriptions: boolean,
+  showSchema: boolean,
+  showTips: boolean = false,
+): Promise<SlashCommandActionReturn> => {
+  const { config } = context.services;
+  if (!config) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Config not loaded.',
+    };
+  }
+
+  const toolRegistry = config.getToolRegistry();
+  if (!toolRegistry) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not retrieve tool registry.',
+    };
+  }
+
+  const mcpServers = config.getMcpServers() || {};
+  const serverNames = Object.keys(mcpServers);
+  const blockedMcpServers = config.getBlockedMcpServers() || [];
+
+  if (serverNames.length === 0 && blockedMcpServers.length === 0) {
+    const docsUrl =
+      'https://qwenlm.github.io/qwen-code-docs/en/tools/mcp-server/#how-to-set-up-your-mcp-server';
+    return {
+      type: 'message',
+      messageType: 'info',
+      content: `No MCP servers configured. Please view MCP documentation in your browser: ${docsUrl} or use the cli /docs command`,
+    };
+  }
+
+  // Check if any servers are still connecting
+  const connectingServers = serverNames.filter(
+    (name) => getMCPServerStatus(name) === MCPServerStatus.CONNECTING,
+  );
+  const discoveryState = getMCPDiscoveryState();
+
+  let message = '';
+
+  // Add overall discovery status message if needed
+  if (
+    discoveryState === MCPDiscoveryState.IN_PROGRESS ||
+    connectingServers.length > 0
+  ) {
+    message += `${COLOR_YELLOW}⏳ MCP servers are starting up (${connectingServers.length} initializing)...${RESET_COLOR}\n`;
+    message += `${COLOR_CYAN}Note: First startup may take longer. Tool availability will update automatically.${RESET_COLOR}\n\n`;
+  }
+
+  message += 'Configured MCP servers:\n\n';
+
+  const allTools = toolRegistry.getAllTools();
+  for (const serverName of serverNames) {
+    const serverTools = allTools.filter(
+      (tool) =>
+        tool instanceof DiscoveredMCPTool && tool.serverName === serverName,
+    ) as DiscoveredMCPTool[];
+    const promptRegistry = await config.getPromptRegistry();
+    const serverPrompts = promptRegistry.getPromptsByServer(serverName) || [];
+
+    const originalStatus = getMCPServerStatus(serverName);
+    const hasCachedItems = serverTools.length > 0 || serverPrompts.length > 0;
+
+    // If the server is "disconnected" but has prompts or cached tools, display it as Ready
+    // by using CONNECTED as the display status.
+    const status =
+      originalStatus === MCPServerStatus.DISCONNECTED && hasCachedItems
+        ? MCPServerStatus.CONNECTED
+        : originalStatus;
+
+    // Add status indicator with descriptive text
+    let statusIndicator = '';
+    let statusText = '';
+    switch (status) {
+      case MCPServerStatus.CONNECTED:
+        statusIndicator = '🟢';
+        statusText = 'Ready';
+        break;
+      case MCPServerStatus.CONNECTING:
+        statusIndicator = '🔄';
+        statusText = 'Starting... (first startup may take longer)';
+        break;
+      case MCPServerStatus.DISCONNECTED:
+      default:
+        statusIndicator = '🔴';
+        statusText = 'Disconnected';
+        break;
+    }
+
+    // Get server description if available
+    const server = mcpServers[serverName];
+    let serverDisplayName = serverName;
+    if (server.extensionName) {
+      serverDisplayName += ` (from ${server.extensionName})`;
+    }
+
+    // Format server header with bold formatting and status
+    message += `${statusIndicator} \u001b[1m${serverDisplayName}\u001b[0m - ${statusText}`;
+
+    let needsAuthHint = mcpServerRequiresOAuth.get(serverName) || false;
+    // Add OAuth status if applicable
+    if (server?.oauth?.enabled) {
+      needsAuthHint = true;
+      try {
+        const { MCPOAuthTokenStorage } = await import(
+          '@qwen-code/qwen-code-core'
+        );
+        const hasToken = await MCPOAuthTokenStorage.getToken(serverName);
+        if (hasToken) {
+          const isExpired = MCPOAuthTokenStorage.isTokenExpired(hasToken.token);
+          if (isExpired) {
+            message += ` ${COLOR_YELLOW}(OAuth token expired)${RESET_COLOR}`;
+          } else {
+            message += ` ${COLOR_GREEN}(OAuth authenticated)${RESET_COLOR}`;
+            needsAuthHint = false;
+          }
+        } else {
+          message += ` ${COLOR_RED}(OAuth not authenticated)${RESET_COLOR}`;
+        }
+      } catch (_err) {
+        // If we can't check OAuth status, just continue
+      }
+    }
+
+    // Add tool count with conditional messaging
+    if (status === MCPServerStatus.CONNECTED) {
+      const parts = [];
+      if (serverTools.length > 0) {
+        parts.push(
+          `${serverTools.length} ${serverTools.length === 1 ? 'tool' : 'tools'}`,
+        );
+      }
+      if (serverPrompts.length > 0) {
+        parts.push(
+          `${serverPrompts.length} ${
+            serverPrompts.length === 1 ? 'prompt' : 'prompts'
+          }`,
+        );
+      }
+      if (parts.length > 0) {
+        message += ` (${parts.join(', ')})`;
+      } else {
+        message += ` (0 tools)`;
+      }
+    } else if (status === MCPServerStatus.CONNECTING) {
+      message += ` (tools and prompts will appear when ready)`;
+    } else {
+      message += ` (${serverTools.length} tools cached)`;
+    }
+
+    // Add server description with proper handling of multi-line descriptions
+    if (showDescriptions && server?.description) {
+      const descLines = server.description.trim().split('\n');
+      if (descLines) {
+        message += ':\n';
+        for (const descLine of descLines) {
+          message += `    ${COLOR_GREEN}${descLine}${RESET_COLOR}\n`;
+        }
+      } else {
+        message += '\n';
+      }
+    } else {
+      message += '\n';
+    }
+
+    // Reset formatting after server entry
+    message += RESET_COLOR;
+
+    if (serverTools.length > 0) {
+      message += `  ${COLOR_CYAN}Tools:${RESET_COLOR}\n`;
+      serverTools.forEach((tool) => {
+        if (showDescriptions && tool.description) {
+          // Format tool name in cyan using simple ANSI cyan color
+          message += `  - ${COLOR_CYAN}${tool.name}${RESET_COLOR}`;
+
+          // Handle multi-line descriptions by properly indenting and preserving formatting
+          const descLines = tool.description.trim().split('\n');
+          if (descLines) {
+            message += ':\n';
+            for (const descLine of descLines) {
+              message += `      ${COLOR_GREEN}${descLine}${RESET_COLOR}\n`;
+            }
+          } else {
+            message += '\n';
+          }
+          // Reset is handled inline with each line now
+        } else {
+          // Use cyan color for the tool name even when not showing descriptions
+          message += `  - ${COLOR_CYAN}${tool.name}${RESET_COLOR}\n`;
+        }
+        const parameters =
+          tool.schema.parametersJsonSchema ?? tool.schema.parameters;
+        if (showSchema && parameters) {
+          // Prefix the parameters in cyan
+          message += `    ${COLOR_CYAN}Parameters:${RESET_COLOR}\n`;
+
+          const paramsLines = JSON.stringify(parameters, null, 2)
+            .trim()
+            .split('\n');
+          if (paramsLines) {
+            for (const paramsLine of paramsLines) {
+              message += `      ${COLOR_GREEN}${paramsLine}${RESET_COLOR}\n`;
+            }
+          }
+        }
+      });
+    }
+    if (serverPrompts.length > 0) {
+      if (serverTools.length > 0) {
+        message += '\n';
+      }
+      message += `  ${COLOR_CYAN}Prompts:${RESET_COLOR}\n`;
+      serverPrompts.forEach((prompt: DiscoveredMCPPrompt) => {
+        if (showDescriptions && prompt.description) {
+          message += `  - ${COLOR_CYAN}${prompt.name}${RESET_COLOR}`;
+          const descLines = prompt.description.trim().split('\n');
+          if (descLines) {
+            message += ':\n';
+            for (const descLine of descLines) {
+              message += `      ${COLOR_GREEN}${descLine}${RESET_COLOR}\n`;
+            }
+          } else {
+            message += '\n';
+          }
+        } else {
+          message += `  - ${COLOR_CYAN}${prompt.name}${RESET_COLOR}\n`;
+        }
+      });
+    }
+
+    if (serverTools.length === 0 && serverPrompts.length === 0) {
+      message += '  No tools or prompts available\n';
+    } else if (serverTools.length === 0) {
+      message += '  No tools available';
+      if (originalStatus === MCPServerStatus.DISCONNECTED && needsAuthHint) {
+        message += ` ${COLOR_GREY}(type: "/mcp auth ${serverName}" to authenticate this server)${RESET_COLOR}`;
+      }
+      message += '\n';
+    } else if (
+      originalStatus === MCPServerStatus.DISCONNECTED &&
+      needsAuthHint
+    ) {
+      // This case is for when serverTools.length > 0
+      message += `  ${COLOR_GREY}(type: "/mcp auth ${serverName}" to authenticate this server)${RESET_COLOR}\n`;
+    }
+    message += '\n';
+  }
+
+  for (const server of blockedMcpServers) {
+    let serverDisplayName = server.name;
+    if (server.extensionName) {
+      serverDisplayName += ` (from ${server.extensionName})`;
+    }
+    message += `🔴 \u001b[1m${serverDisplayName}\u001b[0m - Blocked\n\n`;
+  }
+
+  // Add helpful tips when no arguments are provided
+  if (showTips) {
+    message += '\n';
+    message += `${COLOR_CYAN}💡 Tips:${RESET_COLOR}\n`;
+    message += `  • Use ${COLOR_CYAN}/mcp desc${RESET_COLOR} to show server and tool descriptions\n`;
+    message += `  • Use ${COLOR_CYAN}/mcp schema${RESET_COLOR} to show tool parameter schemas\n`;
+    message += `  • Use ${COLOR_CYAN}/mcp nodesc${RESET_COLOR} to hide descriptions\n`;
+    message += `  • Use ${COLOR_CYAN}/mcp auth <server-name>${RESET_COLOR} to authenticate with OAuth-enabled servers\n`;
+    message += `  • Press ${COLOR_CYAN}Ctrl+T${RESET_COLOR} to toggle tool descriptions on/off\n`;
+    message += '\n';
+  }
+
+  // Make sure to reset any ANSI formatting at the end to prevent it from affecting the terminal
+  message += RESET_COLOR;
+
+  return {
+    type: 'message',
+    messageType: 'info',
+    content: message,
+  };
+};
+
+const authCommand: SlashCommand = {
+  name: 'auth',
+  description: 'Authenticate with an OAuth-enabled MCP server',
+  kind: CommandKind.BUILT_IN,
+  action: async (
+    context: CommandContext,
+    args: string,
+  ): Promise<MessageActionReturn> => {
+    const serverName = args.trim();
+    const { config } = context.services;
+
+    if (!config) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      };
+    }
+
+    const mcpServers = config.getMcpServers() || {};
+
+    if (!serverName) {
+      // List servers that support OAuth
+      const oauthServers = Object.entries(mcpServers)
+        .filter(([_, server]) => server.oauth?.enabled)
+        .map(([name, _]) => name);
+
+      if (oauthServers.length === 0) {
+        return {
+          type: 'message',
+          messageType: 'info',
+          content: 'No MCP servers configured with OAuth authentication.',
+        };
+      }
+
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `MCP servers with OAuth authentication:\n${oauthServers.map((s) => `  - ${s}`).join('\n')}\n\nUse /mcp auth <server-name> to authenticate.`,
+      };
+    }
+
+    const server = mcpServers[serverName];
+    if (!server) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `MCP server '${serverName}' not found.`,
+      };
+    }
+
+    // Always attempt OAuth authentication, even if not explicitly configured
+    // The authentication process will discover OAuth requirements automatically
+
+    try {
+      context.ui.addItem(
+        {
+          type: 'info',
+          text: `Starting OAuth authentication for MCP server '${serverName}'...`,
+        },
+        Date.now(),
+      );
+
+      // Import dynamically to avoid circular dependencies
+      const { MCPOAuthProvider } = await import('@qwen-code/qwen-code-core');
+
+      let oauthConfig = server.oauth;
+      if (!oauthConfig) {
+        oauthConfig = { enabled: false };
+      }
+
+      // Pass the MCP server URL for OAuth discovery
+      const mcpServerUrl = server.httpUrl || server.url;
+      await MCPOAuthProvider.authenticate(
+        serverName,
+        oauthConfig,
+        mcpServerUrl,
+      );
+
+      context.ui.addItem(
+        {
+          type: 'info',
+          text: `✅ Successfully authenticated with MCP server '${serverName}'!`,
+        },
+        Date.now(),
+      );
+
+      // Trigger tool re-discovery to pick up authenticated server
+      const toolRegistry = config.getToolRegistry();
+      if (toolRegistry) {
+        context.ui.addItem(
+          {
+            type: 'info',
+            text: `Re-discovering tools from '${serverName}'...`,
+          },
+          Date.now(),
+        );
+        await toolRegistry.discoverToolsForServer(serverName);
+      }
+      // Update the client with the new tools
+      const geminiClient = config.getGeminiClient();
+      if (geminiClient) {
+        await geminiClient.setTools();
+      }
+
+      // Reload the slash commands to reflect the changes.
+      context.ui.reloadCommands();
+
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Successfully authenticated and refreshed tools for '${serverName}'.`,
+      };
+    } catch (error) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `Failed to authenticate with MCP server '${serverName}': ${getErrorMessage(error)}`,
+      };
+    }
+  },
+  completion: async (context: CommandContext, partialArg: string) => {
+    const { config } = context.services;
+    if (!config) return [];
+
+    const mcpServers = config.getMcpServers() || {};
+    return Object.keys(mcpServers).filter((name) =>
+      name.startsWith(partialArg),
+    );
+  },
+};
+
+const listCommand: SlashCommand = {
+  name: 'list',
+  description: 'List configured MCP servers and tools',
+  kind: CommandKind.BUILT_IN,
+  action: async (context: CommandContext, args: string) => {
+    const lowerCaseArgs = args.toLowerCase().split(/\s+/).filter(Boolean);
+
+    const hasDesc =
+      lowerCaseArgs.includes('desc') || lowerCaseArgs.includes('descriptions');
+    const hasNodesc =
+      lowerCaseArgs.includes('nodesc') ||
+      lowerCaseArgs.includes('nodescriptions');
+    const showSchema = lowerCaseArgs.includes('schema');
+
+    // Show descriptions if `desc` or `schema` is present,
+    // but `nodesc` takes precedence and disables them.
+    const showDescriptions = !hasNodesc && (hasDesc || showSchema);
+
+    // Show tips only when no arguments are provided
+    const showTips = lowerCaseArgs.length === 0;
+
+    return getMcpStatus(context, showDescriptions, showSchema, showTips);
+  },
+};
+
+const refreshCommand: SlashCommand = {
+  name: 'refresh',
+  description: 'Restarts MCP servers.',
+  kind: CommandKind.BUILT_IN,
+  action: async (
+    context: CommandContext,
+  ): Promise<SlashCommandActionReturn> => {
+    const { config } = context.services;
+    if (!config) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Config not loaded.',
+      };
+    }
+
+    const toolRegistry = config.getToolRegistry();
+    if (!toolRegistry) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not retrieve tool registry.',
+      };
+    }
+
+    context.ui.addItem(
+      {
+        type: 'info',
+        text: 'Restarting MCP servers...',
+      },
+      Date.now(),
+    );
+
+    await toolRegistry.restartMcpServers();
+
+    // Update the client with the new tools
+    const geminiClient = config.getGeminiClient();
+    if (geminiClient) {
+      await geminiClient.setTools();
+    }
+
+    // Reload the slash commands to reflect the changes.
+    context.ui.reloadCommands();
+
+    return getMcpStatus(context, false, false, false);
+  },
+};
+
+export const mcpCommand: SlashCommand = {
+  name: 'mcp',
+  description:
+    'list configured MCP servers and tools, or authenticate with OAuth-enabled servers',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [listCommand, authCommand, refreshCommand],
+  // Default action when no subcommand is provided
+  action: async (context: CommandContext, args: string) =>
+    // If no subcommand, run the list command
+    listCommand.action!(context, args),
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/memoryCommand.test.ts

@@ -0,0 +1,344 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, Mock } from 'vitest';
+import { memoryCommand } from './memoryCommand.js';
+import { type CommandContext, SlashCommand } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { MessageType } from '../types.js';
+import { LoadedSettings } from '../../config/settings.js';
+import {
+  getErrorMessage,
+  loadServerHierarchicalMemory,
+  type FileDiscoveryService,
+} from '@qwen-code/qwen-code-core';
+
+vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
+  return {
+    ...original,
+    getErrorMessage: vi.fn((error: unknown) => {
+      if (error instanceof Error) return error.message;
+      return String(error);
+    }),
+    loadServerHierarchicalMemory: vi.fn(),
+  };
+});
+
+const mockLoadServerHierarchicalMemory = loadServerHierarchicalMemory as Mock;
+
+describe('memoryCommand', () => {
+  let mockContext: CommandContext;
+
+  const getSubCommand = (name: 'show' | 'add' | 'refresh'): SlashCommand => {
+    const subCommand = memoryCommand.subCommands?.find(
+      (cmd) => cmd.name === name,
+    );
+    if (!subCommand) {
+      throw new Error(`/memory ${name} command not found.`);
+    }
+    return subCommand;
+  };
+
+  describe('/memory show', () => {
+    let showCommand: SlashCommand;
+    let mockGetUserMemory: Mock;
+    let mockGetGeminiMdFileCount: Mock;
+
+    beforeEach(() => {
+      showCommand = getSubCommand('show');
+
+      mockGetUserMemory = vi.fn();
+      mockGetGeminiMdFileCount = vi.fn();
+
+      mockContext = createMockCommandContext({
+        services: {
+          config: {
+            getUserMemory: mockGetUserMemory,
+            getGeminiMdFileCount: mockGetGeminiMdFileCount,
+          },
+        },
+      });
+    });
+
+    it('should display a message if memory is empty', async () => {
+      if (!showCommand.action) throw new Error('Command has no action');
+
+      mockGetUserMemory.mockReturnValue('');
+      mockGetGeminiMdFileCount.mockReturnValue(0);
+
+      await showCommand.action(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: 'Memory is currently empty.',
+        },
+        expect.any(Number),
+      );
+    });
+
+    it('should display the memory content and file count if it exists', async () => {
+      if (!showCommand.action) throw new Error('Command has no action');
+
+      const memoryContent = 'This is a test memory.';
+
+      mockGetUserMemory.mockReturnValue(memoryContent);
+      mockGetGeminiMdFileCount.mockReturnValue(1);
+
+      await showCommand.action(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Current memory content from 1 file(s):\n\n---\n${memoryContent}\n---`,
+        },
+        expect.any(Number),
+      );
+    });
+  });
+
+  describe('/memory add', () => {
+    let addCommand: SlashCommand;
+
+    beforeEach(() => {
+      addCommand = getSubCommand('add');
+      mockContext = createMockCommandContext();
+    });
+
+    it('should return an error message if no arguments are provided', () => {
+      if (!addCommand.action) throw new Error('Command has no action');
+
+      const result = addCommand.action(mockContext, '  ');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Usage: /memory add [--global|--project] <text to remember>',
+      });
+
+      expect(mockContext.ui.addItem).not.toHaveBeenCalled();
+    });
+
+    it('should return a tool action and add an info message when arguments are provided', () => {
+      if (!addCommand.action) throw new Error('Command has no action');
+
+      const fact = 'remember this';
+      const result = addCommand.action(mockContext, `  ${fact}  `);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Attempting to save to memory : "${fact}"`,
+        },
+        expect.any(Number),
+      );
+
+      expect(result).toEqual({
+        type: 'tool',
+        toolName: 'save_memory',
+        toolArgs: { fact },
+      });
+    });
+
+    it('should handle --global flag and add scope to tool args', () => {
+      if (!addCommand.action) throw new Error('Command has no action');
+
+      const fact = 'remember this globally';
+      const result = addCommand.action(mockContext, `--global ${fact}`);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Attempting to save to memory (global): "${fact}"`,
+        },
+        expect.any(Number),
+      );
+
+      expect(result).toEqual({
+        type: 'tool',
+        toolName: 'save_memory',
+        toolArgs: { fact, scope: 'global' },
+      });
+    });
+
+    it('should handle --project flag and add scope to tool args', () => {
+      if (!addCommand.action) throw new Error('Command has no action');
+
+      const fact = 'remember this for project';
+      const result = addCommand.action(mockContext, `--project ${fact}`);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: `Attempting to save to memory (project): "${fact}"`,
+        },
+        expect.any(Number),
+      );
+
+      expect(result).toEqual({
+        type: 'tool',
+        toolName: 'save_memory',
+        toolArgs: { fact, scope: 'project' },
+      });
+    });
+
+    it('should return error if flag is provided but no fact follows', () => {
+      if (!addCommand.action) throw new Error('Command has no action');
+
+      const result = addCommand.action(mockContext, '--global   ');
+      expect(result).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Usage: /memory add [--global|--project] <text to remember>',
+      });
+
+      expect(mockContext.ui.addItem).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('/memory refresh', () => {
+    let refreshCommand: SlashCommand;
+    let mockSetUserMemory: Mock;
+    let mockSetGeminiMdFileCount: Mock;
+
+    beforeEach(() => {
+      refreshCommand = getSubCommand('refresh');
+      mockSetUserMemory = vi.fn();
+      mockSetGeminiMdFileCount = vi.fn();
+      const mockConfig = {
+        setUserMemory: mockSetUserMemory,
+        setGeminiMdFileCount: mockSetGeminiMdFileCount,
+        getWorkingDir: () => '/test/dir',
+        getDebugMode: () => false,
+        getFileService: () => ({}) as FileDiscoveryService,
+        getExtensionContextFilePaths: () => [],
+        shouldLoadMemoryFromIncludeDirectories: () => false,
+        getWorkspaceContext: () => ({
+          getDirectories: () => [],
+        }),
+        getFileFilteringOptions: () => ({
+          ignore: [],
+          include: [],
+        }),
+      };
+
+      mockContext = createMockCommandContext({
+        services: {
+          config: mockConfig,
+          settings: {
+            merged: {
+              memoryDiscoveryMaxDirs: 1000,
+            },
+          } as LoadedSettings,
+        },
+      });
+      mockLoadServerHierarchicalMemory.mockClear();
+    });
+
+    it('should display success message when memory is refreshed with content', async () => {
+      if (!refreshCommand.action) throw new Error('Command has no action');
+
+      const refreshResult = {
+        memoryContent: 'new memory content',
+        fileCount: 2,
+      };
+      mockLoadServerHierarchicalMemory.mockResolvedValue(refreshResult);
+
+      await refreshCommand.action(mockContext, '');
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: 'Refreshing memory from source files...',
+        },
+        expect.any(Number),
+      );
+
+      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
+      expect(mockSetUserMemory).toHaveBeenCalledWith(
+        refreshResult.memoryContent,
+      );
+      expect(mockSetGeminiMdFileCount).toHaveBeenCalledWith(
+        refreshResult.fileCount,
+      );
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: 'Memory refreshed successfully. Loaded 18 characters from 2 file(s).',
+        },
+        expect.any(Number),
+      );
+    });
+
+    it('should display success message when memory is refreshed with no content', async () => {
+      if (!refreshCommand.action) throw new Error('Command has no action');
+
+      const refreshResult = { memoryContent: '', fileCount: 0 };
+      mockLoadServerHierarchicalMemory.mockResolvedValue(refreshResult);
+
+      await refreshCommand.action(mockContext, '');
+
+      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
+      expect(mockSetUserMemory).toHaveBeenCalledWith('');
+      expect(mockSetGeminiMdFileCount).toHaveBeenCalledWith(0);
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: 'Memory refreshed successfully. No memory content found.',
+        },
+        expect.any(Number),
+      );
+    });
+
+    it('should display an error message if refreshing fails', async () => {
+      if (!refreshCommand.action) throw new Error('Command has no action');
+
+      const error = new Error('Failed to read memory files.');
+      mockLoadServerHierarchicalMemory.mockRejectedValue(error);
+
+      await refreshCommand.action(mockContext, '');
+
+      expect(loadServerHierarchicalMemory).toHaveBeenCalledOnce();
+      expect(mockSetUserMemory).not.toHaveBeenCalled();
+      expect(mockSetGeminiMdFileCount).not.toHaveBeenCalled();
+
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.ERROR,
+          text: `Error refreshing memory: ${error.message}`,
+        },
+        expect.any(Number),
+      );
+
+      expect(getErrorMessage).toHaveBeenCalledWith(error);
+    });
+
+    it('should not throw if config service is unavailable', async () => {
+      if (!refreshCommand.action) throw new Error('Command has no action');
+
+      const nullConfigContext = createMockCommandContext({
+        services: { config: null },
+      });
+
+      await expect(
+        refreshCommand.action(nullConfigContext, ''),
+      ).resolves.toBeUndefined();
+
+      expect(nullConfigContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: MessageType.INFO,
+          text: 'Refreshing memory from source files...',
+        },
+        expect.any(Number),
+      );
+
+      expect(loadServerHierarchicalMemory).not.toHaveBeenCalled();
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/memoryCommand.ts

@@ -0,0 +1,305 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  getErrorMessage,
+  loadServerHierarchicalMemory,
+  QWEN_DIR,
+} from '@qwen-code/qwen-code-core';
+import path from 'node:path';
+import os from 'os';
+import fs from 'fs/promises';
+import { MessageType } from '../types.js';
+import {
+  CommandKind,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+
+export const memoryCommand: SlashCommand = {
+  name: 'memory',
+  description: 'Commands for interacting with memory.',
+  kind: CommandKind.BUILT_IN,
+  subCommands: [
+    {
+      name: 'show',
+      description: 'Show the current memory contents.',
+      kind: CommandKind.BUILT_IN,
+      action: async (context) => {
+        const memoryContent = context.services.config?.getUserMemory() || '';
+        const fileCount = context.services.config?.getGeminiMdFileCount() || 0;
+
+        const messageContent =
+          memoryContent.length > 0
+            ? `Current memory content from ${fileCount} file(s):\n\n---\n${memoryContent}\n---`
+            : 'Memory is currently empty.';
+
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: messageContent,
+          },
+          Date.now(),
+        );
+      },
+      subCommands: [
+        {
+          name: '--project',
+          description: 'Show project-level memory contents.',
+          kind: CommandKind.BUILT_IN,
+          action: async (context) => {
+            try {
+              const projectMemoryPath = path.join(process.cwd(), 'QWEN.md');
+              const memoryContent = await fs.readFile(
+                projectMemoryPath,
+                'utf-8',
+              );
+
+              const messageContent =
+                memoryContent.trim().length > 0
+                  ? `Project memory content from ${projectMemoryPath}:\n\n---\n${memoryContent}\n---`
+                  : 'Project memory is currently empty.';
+
+              context.ui.addItem(
+                {
+                  type: MessageType.INFO,
+                  text: messageContent,
+                },
+                Date.now(),
+              );
+            } catch (_error) {
+              context.ui.addItem(
+                {
+                  type: MessageType.INFO,
+                  text: 'Project memory file not found or is currently empty.',
+                },
+                Date.now(),
+              );
+            }
+          },
+        },
+        {
+          name: '--global',
+          description: 'Show global memory contents.',
+          kind: CommandKind.BUILT_IN,
+          action: async (context) => {
+            try {
+              const globalMemoryPath = path.join(
+                os.homedir(),
+                QWEN_DIR,
+                'QWEN.md',
+              );
+              const globalMemoryContent = await fs.readFile(
+                globalMemoryPath,
+                'utf-8',
+              );
+
+              const messageContent =
+                globalMemoryContent.trim().length > 0
+                  ? `Global memory content:\n\n---\n${globalMemoryContent}\n---`
+                  : 'Global memory is currently empty.';
+
+              context.ui.addItem(
+                {
+                  type: MessageType.INFO,
+                  text: messageContent,
+                },
+                Date.now(),
+              );
+            } catch (_error) {
+              context.ui.addItem(
+                {
+                  type: MessageType.INFO,
+                  text: 'Global memory file not found or is currently empty.',
+                },
+                Date.now(),
+              );
+            }
+          },
+        },
+      ],
+    },
+    {
+      name: 'add',
+      description:
+        'Add content to the memory. Use --global for global memory or --project for project memory.',
+      kind: CommandKind.BUILT_IN,
+      action: (context, args): SlashCommandActionReturn | void => {
+        if (!args || args.trim() === '') {
+          return {
+            type: 'message',
+            messageType: 'error',
+            content:
+              'Usage: /memory add [--global|--project] <text to remember>',
+          };
+        }
+
+        const trimmedArgs = args.trim();
+        let scope: 'global' | 'project' | undefined;
+        let fact: string;
+
+        // Check for scope flags
+        if (trimmedArgs.startsWith('--global ')) {
+          scope = 'global';
+          fact = trimmedArgs.substring('--global '.length).trim();
+        } else if (trimmedArgs.startsWith('--project ')) {
+          scope = 'project';
+          fact = trimmedArgs.substring('--project '.length).trim();
+        } else if (trimmedArgs === '--global' || trimmedArgs === '--project') {
+          // Flag provided but no text after it
+          return {
+            type: 'message',
+            messageType: 'error',
+            content:
+              'Usage: /memory add [--global|--project] <text to remember>',
+          };
+        } else {
+          // No scope specified, will be handled by the tool
+          fact = trimmedArgs;
+        }
+
+        if (!fact || fact.trim() === '') {
+          return {
+            type: 'message',
+            messageType: 'error',
+            content:
+              'Usage: /memory add [--global|--project] <text to remember>',
+          };
+        }
+
+        const scopeText = scope ? `(${scope})` : '';
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: `Attempting to save to memory ${scopeText}: "${fact}"`,
+          },
+          Date.now(),
+        );
+
+        return {
+          type: 'tool',
+          toolName: 'save_memory',
+          toolArgs: scope ? { fact, scope } : { fact },
+        };
+      },
+      subCommands: [
+        {
+          name: '--project',
+          description: 'Add content to project-level memory.',
+          kind: CommandKind.BUILT_IN,
+          action: (context, args): SlashCommandActionReturn | void => {
+            if (!args || args.trim() === '') {
+              return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Usage: /memory add --project <text to remember>',
+              };
+            }
+
+            context.ui.addItem(
+              {
+                type: MessageType.INFO,
+                text: `Attempting to save to project memory: "${args.trim()}"`,
+              },
+              Date.now(),
+            );
+
+            return {
+              type: 'tool',
+              toolName: 'save_memory',
+              toolArgs: { fact: args.trim(), scope: 'project' },
+            };
+          },
+        },
+        {
+          name: '--global',
+          description: 'Add content to global memory.',
+          kind: CommandKind.BUILT_IN,
+          action: (context, args): SlashCommandActionReturn | void => {
+            if (!args || args.trim() === '') {
+              return {
+                type: 'message',
+                messageType: 'error',
+                content: 'Usage: /memory add --global <text to remember>',
+              };
+            }
+
+            context.ui.addItem(
+              {
+                type: MessageType.INFO,
+                text: `Attempting to save to global memory: "${args.trim()}"`,
+              },
+              Date.now(),
+            );
+
+            return {
+              type: 'tool',
+              toolName: 'save_memory',
+              toolArgs: { fact: args.trim(), scope: 'global' },
+            };
+          },
+        },
+      ],
+    },
+    {
+      name: 'refresh',
+      description: 'Refresh the memory from the source.',
+      kind: CommandKind.BUILT_IN,
+      action: async (context) => {
+        context.ui.addItem(
+          {
+            type: MessageType.INFO,
+            text: 'Refreshing memory from source files...',
+          },
+          Date.now(),
+        );
+
+        try {
+          const config = context.services.config;
+          if (config) {
+            const { memoryContent, fileCount } =
+              await loadServerHierarchicalMemory(
+                config.getWorkingDir(),
+                config.shouldLoadMemoryFromIncludeDirectories()
+                  ? config.getWorkspaceContext().getDirectories()
+                  : [],
+                config.getDebugMode(),
+                config.getFileService(),
+                config.getExtensionContextFilePaths(),
+                context.services.settings.merged.memoryImportFormat || 'tree', // Use setting or default to 'tree'
+                config.getFileFilteringOptions(),
+                context.services.settings.merged.memoryDiscoveryMaxDirs,
+              );
+            config.setUserMemory(memoryContent);
+            config.setGeminiMdFileCount(fileCount);
+
+            const successMessage =
+              memoryContent.length > 0
+                ? `Memory refreshed successfully. Loaded ${memoryContent.length} characters from ${fileCount} file(s).`
+                : 'Memory refreshed successfully. No memory content found.';
+
+            context.ui.addItem(
+              {
+                type: MessageType.INFO,
+                text: successMessage,
+              },
+              Date.now(),
+            );
+          }
+        } catch (error) {
+          const errorMessage = getErrorMessage(error);
+          context.ui.addItem(
+            {
+              type: MessageType.ERROR,
+              text: `Error refreshing memory: ${errorMessage}`,
+            },
+            Date.now(),
+          );
+        }
+      },
+    },
+  ],
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/privacyCommand.test.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { privacyCommand } from './privacyCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('privacyCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext();
+  });
+
+  it('should return a dialog action to open the privacy dialog', () => {
+    // Ensure the command has an action to test.
+    if (!privacyCommand.action) {
+      throw new Error('The privacy command must have an action.');
+    }
+
+    const result = privacyCommand.action(mockContext, '');
+
+    // Assert that the action returns the correct object to trigger the privacy dialog.
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'privacy',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(privacyCommand.name).toBe('privacy');
+    expect(privacyCommand.description).toBe('display the privacy notice');
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/privacyCommand.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, OpenDialogActionReturn, SlashCommand } from './types.js';
+
+export const privacyCommand: SlashCommand = {
+  name: 'privacy',
+  description: 'display the privacy notice',
+  kind: CommandKind.BUILT_IN,
+  action: (): OpenDialogActionReturn => ({
+    type: 'dialog',
+    dialog: 'privacy',
+  }),
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/quitCommand.test.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { quitCommand } from './quitCommand.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { formatDuration } from '../utils/formatters.js';
+
+vi.mock('../utils/formatters.js');
+
+describe('quitCommand', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-01-01T01:00:00Z'));
+    vi.mocked(formatDuration).mockReturnValue('1h 0m 0s');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+  });
+
+  it('returns a QuitActionReturn object with the correct messages', () => {
+    const mockContext = createMockCommandContext({
+      session: {
+        stats: {
+          sessionStartTime: new Date('2025-01-01T00:00:00Z'),
+        },
+      },
+    });
+
+    if (!quitCommand.action) throw new Error('Action is not defined');
+    const result = quitCommand.action(mockContext, 'quit');
+
+    expect(formatDuration).toHaveBeenCalledWith(3600000); // 1 hour in ms
+    expect(result).toEqual({
+      type: 'quit',
+      messages: [
+        {
+          type: 'user',
+          text: '/quit',
+          id: expect.any(Number),
+        },
+        {
+          type: 'quit',
+          duration: '1h 0m 0s',
+          id: expect.any(Number),
+        },
+      ],
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/quitCommand.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { formatDuration } from '../utils/formatters.js';
+import { CommandKind, type SlashCommand } from './types.js';
+
+export const quitCommand: SlashCommand = {
+  name: 'quit',
+  altNames: ['exit'],
+  description: 'exit the cli',
+  kind: CommandKind.BUILT_IN,
+  action: (context) => {
+    const now = Date.now();
+    const { sessionStartTime } = context.session.stats;
+    const wallDuration = now - sessionStartTime.getTime();
+
+    return {
+      type: 'quit',
+      messages: [
+        {
+          type: 'user',
+          text: `/quit`, // Keep it consistent, even if /exit was used
+          id: now - 1,
+        },
+        {
+          type: 'quit',
+          duration: formatDuration(wallDuration),
+          id: now,
+        },
+      ],
+    };
+  },
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/restoreCommand.test.ts

@@ -0,0 +1,250 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { restoreCommand } from './restoreCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+import { Config, GitService } from '@qwen-code/qwen-code-core';
+
+describe('restoreCommand', () => {
+  let mockContext: CommandContext;
+  let mockConfig: Config;
+  let mockGitService: GitService;
+  let mockSetHistory: ReturnType<typeof vi.fn>;
+  let testRootDir: string;
+  let geminiTempDir: string;
+  let checkpointsDir: string;
+
+  beforeEach(async () => {
+    testRootDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'restore-command-test-'),
+    );
+    geminiTempDir = path.join(testRootDir, '.gemini');
+    checkpointsDir = path.join(geminiTempDir, 'checkpoints');
+    // The command itself creates this, but for tests it's easier to have it ready.
+    // Some tests might remove it to test error paths.
+    await fs.mkdir(checkpointsDir, { recursive: true });
+
+    mockSetHistory = vi.fn().mockResolvedValue(undefined);
+    mockGitService = {
+      restoreProjectFromSnapshot: vi.fn().mockResolvedValue(undefined),
+    } as unknown as GitService;
+
+    mockConfig = {
+      getCheckpointingEnabled: vi.fn().mockReturnValue(true),
+      getProjectTempDir: vi.fn().mockReturnValue(geminiTempDir),
+      getGeminiClient: vi.fn().mockReturnValue({
+        setHistory: mockSetHistory,
+      }),
+    } as unknown as Config;
+
+    mockContext = createMockCommandContext({
+      services: {
+        config: mockConfig,
+        git: mockGitService,
+      },
+    });
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await fs.rm(testRootDir, { recursive: true, force: true });
+  });
+
+  it('should return null if checkpointing is not enabled', () => {
+    vi.mocked(mockConfig.getCheckpointingEnabled).mockReturnValue(false);
+
+    expect(restoreCommand(mockConfig)).toBeNull();
+  });
+
+  it('should return the command if checkpointing is enabled', () => {
+    expect(restoreCommand(mockConfig)).toEqual(
+      expect.objectContaining({
+        name: 'restore',
+        description: expect.any(String),
+        action: expect.any(Function),
+        completion: expect.any(Function),
+      }),
+    );
+  });
+
+  describe('action', () => {
+    it('should return an error if temp dir is not found', async () => {
+      vi.mocked(mockConfig.getProjectTempDir).mockReturnValue('');
+
+      expect(
+        await restoreCommand(mockConfig)?.action?.(mockContext, ''),
+      ).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'Could not determine the .gemini directory path.',
+      });
+    });
+
+    it('should inform when no checkpoints are found if no args are passed', async () => {
+      // Remove the directory to ensure the command creates it.
+      await fs.rm(checkpointsDir, { recursive: true, force: true });
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, '')).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'No restorable tool calls found.',
+      });
+      // Verify the directory was created by the command.
+      await expect(fs.stat(checkpointsDir)).resolves.toBeDefined();
+    });
+
+    it('should list available checkpoints if no args are passed', async () => {
+      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
+      await fs.writeFile(path.join(checkpointsDir, 'test2.json'), '{}');
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, '')).toEqual({
+        type: 'message',
+        messageType: 'info',
+        content: 'Available tool calls to restore:\n\ntest1\ntest2',
+      });
+    });
+
+    it('should return an error if the specified file is not found', async () => {
+      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, 'test2')).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: 'File not found: test2.json',
+      });
+    });
+
+    it('should handle file read errors gracefully', async () => {
+      const checkpointName = 'test1';
+      const checkpointPath = path.join(
+        checkpointsDir,
+        `${checkpointName}.json`,
+      );
+      // Create a directory instead of a file to cause a read error.
+      await fs.mkdir(checkpointPath);
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, checkpointName)).toEqual({
+        type: 'message',
+        messageType: 'error',
+        content: expect.stringContaining(
+          'Could not read restorable tool calls.',
+        ),
+      });
+    });
+
+    it('should restore a tool call and project state', async () => {
+      const toolCallData = {
+        history: [{ type: 'user', text: 'do a thing' }],
+        clientHistory: [{ role: 'user', parts: [{ text: 'do a thing' }] }],
+        commitHash: 'abcdef123',
+        toolCall: { name: 'run_shell_command', args: 'ls' },
+      };
+      await fs.writeFile(
+        path.join(checkpointsDir, 'my-checkpoint.json'),
+        JSON.stringify(toolCallData),
+      );
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, 'my-checkpoint')).toEqual({
+        type: 'tool',
+        toolName: 'run_shell_command',
+        toolArgs: 'ls',
+      });
+      expect(mockContext.ui.loadHistory).toHaveBeenCalledWith(
+        toolCallData.history,
+      );
+      expect(mockSetHistory).toHaveBeenCalledWith(toolCallData.clientHistory);
+      expect(mockGitService.restoreProjectFromSnapshot).toHaveBeenCalledWith(
+        toolCallData.commitHash,
+      );
+      expect(mockContext.ui.addItem).toHaveBeenCalledWith(
+        {
+          type: 'info',
+          text: 'Restored project to the state before the tool call.',
+        },
+        expect.any(Number),
+      );
+    });
+
+    it('should restore even if only toolCall is present', async () => {
+      const toolCallData = {
+        toolCall: { name: 'run_shell_command', args: 'ls' },
+      };
+      await fs.writeFile(
+        path.join(checkpointsDir, 'my-checkpoint.json'),
+        JSON.stringify(toolCallData),
+      );
+
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.action?.(mockContext, 'my-checkpoint')).toEqual({
+        type: 'tool',
+        toolName: 'run_shell_command',
+        toolArgs: 'ls',
+      });
+
+      expect(mockContext.ui.loadHistory).not.toHaveBeenCalled();
+      expect(mockSetHistory).not.toHaveBeenCalled();
+      expect(mockGitService.restoreProjectFromSnapshot).not.toHaveBeenCalled();
+    });
+  });
+
+  it('should return an error for a checkpoint file missing the toolCall property', async () => {
+    const checkpointName = 'missing-toolcall';
+    await fs.writeFile(
+      path.join(checkpointsDir, `${checkpointName}.json`),
+      JSON.stringify({ history: [] }), // An object that is valid JSON but missing the 'toolCall' property
+    );
+    const command = restoreCommand(mockConfig);
+
+    expect(await command?.action?.(mockContext, checkpointName)).toEqual({
+      type: 'message',
+      messageType: 'error',
+      // A more specific error message would be ideal, but for now, we can assert the current behavior.
+      content: expect.stringContaining('Could not read restorable tool calls.'),
+    });
+  });
+
+  describe('completion', () => {
+    it('should return an empty array if temp dir is not found', async () => {
+      vi.mocked(mockConfig.getProjectTempDir).mockReturnValue('');
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.completion?.(mockContext, '')).toEqual([]);
+    });
+
+    it('should return an empty array on readdir error', async () => {
+      await fs.rm(checkpointsDir, { recursive: true, force: true });
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.completion?.(mockContext, '')).toEqual([]);
+    });
+
+    it('should return a list of checkpoint names', async () => {
+      await fs.writeFile(path.join(checkpointsDir, 'test1.json'), '{}');
+      await fs.writeFile(path.join(checkpointsDir, 'test2.json'), '{}');
+      await fs.writeFile(
+        path.join(checkpointsDir, 'not-a-checkpoint.txt'),
+        '{}',
+      );
+      const command = restoreCommand(mockConfig);
+
+      expect(await command?.completion?.(mockContext, '')).toEqual([
+        'test1',
+        'test2',
+      ]);
+    });
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/restoreCommand.ts

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as fs from 'fs/promises';
+import path from 'path';
+import {
+  type CommandContext,
+  type SlashCommand,
+  type SlashCommandActionReturn,
+  CommandKind,
+} from './types.js';
+import { Config } from '@qwen-code/qwen-code-core';
+
+async function restoreAction(
+  context: CommandContext,
+  args: string,
+): Promise<void | SlashCommandActionReturn> {
+  const { services, ui } = context;
+  const { config, git: gitService } = services;
+  const { addItem, loadHistory } = ui;
+
+  const checkpointDir = config?.getProjectTempDir()
+    ? path.join(config.getProjectTempDir(), 'checkpoints')
+    : undefined;
+
+  if (!checkpointDir) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: 'Could not determine the .gemini directory path.',
+    };
+  }
+
+  try {
+    // Ensure the directory exists before trying to read it.
+    await fs.mkdir(checkpointDir, { recursive: true });
+    const files = await fs.readdir(checkpointDir);
+    const jsonFiles = files.filter((file) => file.endsWith('.json'));
+
+    if (!args) {
+      if (jsonFiles.length === 0) {
+        return {
+          type: 'message',
+          messageType: 'info',
+          content: 'No restorable tool calls found.',
+        };
+      }
+      const truncatedFiles = jsonFiles.map((file) => {
+        const components = file.split('.');
+        if (components.length <= 1) {
+          return file;
+        }
+        components.pop();
+        return components.join('.');
+      });
+      const fileList = truncatedFiles.join('\n');
+      return {
+        type: 'message',
+        messageType: 'info',
+        content: `Available tool calls to restore:\n\n${fileList}`,
+      };
+    }
+
+    const selectedFile = args.endsWith('.json') ? args : `${args}.json`;
+
+    if (!jsonFiles.includes(selectedFile)) {
+      return {
+        type: 'message',
+        messageType: 'error',
+        content: `File not found: ${selectedFile}`,
+      };
+    }
+
+    const filePath = path.join(checkpointDir, selectedFile);
+    const data = await fs.readFile(filePath, 'utf-8');
+    const toolCallData = JSON.parse(data);
+
+    if (toolCallData.history) {
+      if (!loadHistory) {
+        // This should not happen
+        return {
+          type: 'message',
+          messageType: 'error',
+          content: 'loadHistory function is not available.',
+        };
+      }
+      loadHistory(toolCallData.history);
+    }
+
+    if (toolCallData.clientHistory) {
+      await config?.getGeminiClient()?.setHistory(toolCallData.clientHistory);
+    }
+
+    if (toolCallData.commitHash) {
+      await gitService?.restoreProjectFromSnapshot(toolCallData.commitHash);
+      addItem(
+        {
+          type: 'info',
+          text: 'Restored project to the state before the tool call.',
+        },
+        Date.now(),
+      );
+    }
+
+    return {
+      type: 'tool',
+      toolName: toolCallData.toolCall.name,
+      toolArgs: toolCallData.toolCall.args,
+    };
+  } catch (error) {
+    return {
+      type: 'message',
+      messageType: 'error',
+      content: `Could not read restorable tool calls. This is the error: ${error}`,
+    };
+  }
+}
+
+async function completion(
+  context: CommandContext,
+  _partialArg: string,
+): Promise<string[]> {
+  const { services } = context;
+  const { config } = services;
+  const checkpointDir = config?.getProjectTempDir()
+    ? path.join(config.getProjectTempDir(), 'checkpoints')
+    : undefined;
+  if (!checkpointDir) {
+    return [];
+  }
+  try {
+    const files = await fs.readdir(checkpointDir);
+    return files
+      .filter((file) => file.endsWith('.json'))
+      .map((file) => file.replace('.json', ''));
+  } catch (_err) {
+    return [];
+  }
+}
+
+export const restoreCommand = (config: Config | null): SlashCommand | null => {
+  if (!config?.getCheckpointingEnabled()) {
+    return null;
+  }
+
+  return {
+    name: 'restore',
+    description:
+      'Restore a tool call. This will reset the conversation and file history to the state it was in when the tool call was suggested',
+    kind: CommandKind.BUILT_IN,
+    action: restoreAction,
+    completion,
+  };
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/settingsCommand.test.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { settingsCommand } from './settingsCommand.js';
+import { type CommandContext } from './types.js';
+import { createMockCommandContext } from '../../test-utils/mockCommandContext.js';
+
+describe('settingsCommand', () => {
+  let mockContext: CommandContext;
+
+  beforeEach(() => {
+    mockContext = createMockCommandContext();
+  });
+
+  it('should return a dialog action to open the settings dialog', () => {
+    if (!settingsCommand.action) {
+      throw new Error('The settings command must have an action.');
+    }
+    const result = settingsCommand.action(mockContext, '');
+    expect(result).toEqual({
+      type: 'dialog',
+      dialog: 'settings',
+    });
+  });
+
+  it('should have the correct name and description', () => {
+    expect(settingsCommand.name).toBe('settings');
+    expect(settingsCommand.description).toBe(
+      'View and edit Qwen Code settings',
+    );
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/settingsCommand.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CommandKind, OpenDialogActionReturn, SlashCommand } from './types.js';
+
+export const settingsCommand: SlashCommand = {
+  name: 'settings',
+  description: 'View and edit Qwen Code settings',
+  kind: CommandKind.BUILT_IN,
+  action: (_context, _args): OpenDialogActionReturn => ({
+    type: 'dialog',
+    dialog: 'settings',
+  }),
+};

projects/ui/qwen-code/packages/cli/src/ui/commands/setupGithubCommand.test.ts

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+import { vi, describe, expect, it, afterEach, beforeEach } from 'vitest';
+import * as gitUtils from '../../utils/gitUtils.js';
+import {
+  setupGithubCommand,
+  updateGitignore,
+  GITHUB_WORKFLOW_PATHS,
+} from './setupGithubCommand.js';
+import { CommandContext, ToolActionReturn } from './types.js';
+import * as commandUtils from '../utils/commandUtils.js';
+
+vi.mock('child_process');
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+vi.mock('../../utils/gitUtils.js', () => ({
+  isGitHubRepository: vi.fn(),
+  getGitRepoRoot: vi.fn(),
+  getLatestGitHubRelease: vi.fn(),
+  getGitHubRepoInfo: vi.fn(),
+}));
+
+vi.mock('../utils/commandUtils.js', () => ({
+  getUrlOpenCommand: vi.fn(),
+}));
+
+describe('setupGithubCommand', async () => {
+  let scratchDir = '';
+
+  beforeEach(async () => {
+    vi.resetAllMocks();
+    scratchDir = await fs.mkdtemp(
+      path.join(os.tmpdir(), 'setup-github-command-'),
+    );
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    if (scratchDir) await fs.rm(scratchDir, { recursive: true });
+  });
+
+  it('returns a tool action to download github workflows and handles paths', async () => {
+    const fakeRepoOwner = 'fake';
+    const fakeRepoName = 'repo';
+    const fakeRepoRoot = scratchDir;
+    const fakeReleaseVersion = 'v1.2.3';
+
+    const workflows = GITHUB_WORKFLOW_PATHS.map((p) => path.basename(p));
+    for (const workflow of workflows) {
+      vi.mocked(global.fetch).mockReturnValueOnce(
+        Promise.resolve(new Response(workflow)),
+      );
+    }
+
+    vi.mocked(gitUtils.isGitHubRepository).mockReturnValueOnce(true);
+    vi.mocked(gitUtils.getGitRepoRoot).mockReturnValueOnce(fakeRepoRoot);
+    vi.mocked(gitUtils.getLatestGitHubRelease).mockResolvedValueOnce(
+      fakeReleaseVersion,
+    );
+    vi.mocked(gitUtils.getGitHubRepoInfo).mockReturnValue({
+      owner: fakeRepoOwner,
+      repo: fakeRepoName,
+    });
+    vi.mocked(commandUtils.getUrlOpenCommand).mockReturnValueOnce(
+      'fakeOpenCommand',
+    );
+
+    const result = (await setupGithubCommand.action?.(
+      {} as CommandContext,
+      '',
+    )) as ToolActionReturn;
+
+    const { command } = result.toolArgs;
+
+    const expectedSubstrings = [
+      `set -eEuo pipefail`,
+      `fakeOpenCommand "https://github.com/google-github-actions/run-gemini-cli`,
+    ];
+
+    for (const substring of expectedSubstrings) {
+      expect(command).toContain(substring);
+    }
+
+    for (const workflow of workflows) {
+      const workflowFile = path.join(
+        scratchDir,
+        '.github',
+        'workflows',
+        workflow,
+      );
+      const contents = await fs.readFile(workflowFile, 'utf8');
+      expect(contents).toContain(workflow);
+    }
+
+    // Verify that .gitignore was created with the expected entries
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const gitignoreExists = await fs
+      .access(gitignorePath)
+      .then(() => true)
+      .catch(() => false);
+    expect(gitignoreExists).toBe(true);
+
+    if (gitignoreExists) {
+      const gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
+      expect(gitignoreContent).toContain('.gemini/');
+      expect(gitignoreContent).toContain('gha-creds-*.json');
+    }
+  });
+});
+
+describe('updateGitignore', () => {
+  let scratchDir = '';
+
+  beforeEach(async () => {
+    scratchDir = await fs.mkdtemp(path.join(os.tmpdir(), 'update-gitignore-'));
+  });
+
+  afterEach(async () => {
+    if (scratchDir) await fs.rm(scratchDir, { recursive: true });
+  });
+
+  it('creates a new .gitignore file when none exists', async () => {
+    await updateGitignore(scratchDir);
+
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe('.gemini/\ngha-creds-*.json\n');
+  });
+
+  it('appends entries to existing .gitignore file', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '# Existing content\nnode_modules/\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe(
+      '# Existing content\nnode_modules/\n\n.gemini/\ngha-creds-*.json\n',
+    );
+  });
+
+  it('does not add duplicate entries', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '.gemini/\nsome-other-file\ngha-creds-*.json\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    expect(content).toBe(existingContent);
+  });
+
+  it('adds only missing entries when some already exist', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = '.gemini/\nsome-other-file\n';
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    // Should add only the missing gha-creds-*.json entry
+    expect(content).toBe('.gemini/\nsome-other-file\n\ngha-creds-*.json\n');
+    expect(content).toContain('gha-creds-*.json');
+    // Should not duplicate .gemini/ entry
+    expect((content.match(/\.gemini\//g) || []).length).toBe(1);
+  });
+
+  it('does not get confused by entries in comments or as substrings', async () => {
+    const gitignorePath = path.join(scratchDir, '.gitignore');
+    const existingContent = [
+      '# This is a comment mentioning .gemini/ folder',
+      'my-app.gemini/config',
+      '# Another comment with gha-creds-*.json pattern',
+      'some-other-gha-creds-file.json',
+      '',
+    ].join('\n');
+    await fs.writeFile(gitignorePath, existingContent);
+
+    await updateGitignore(scratchDir);
+
+    const content = await fs.readFile(gitignorePath, 'utf8');
+
+    // Should add both entries since they don't actually exist as gitignore rules
+    expect(content).toContain('.gemini/');
+    expect(content).toContain('gha-creds-*.json');
+
+    // Verify the entries were added (not just mentioned in comments)
+    const lines = content
+      .split('\n')
+      .map((line) => line.split('#')[0].trim())
+      .filter((line) => line);
+    expect(lines).toContain('.gemini/');
+    expect(lines).toContain('gha-creds-*.json');
+    expect(lines).toContain('my-app.gemini/config');
+    expect(lines).toContain('some-other-gha-creds-file.json');
+  });
+
+  it('handles file system errors gracefully', async () => {
+    // Try to update gitignore in a non-existent directory
+    const nonExistentDir = path.join(scratchDir, 'non-existent');
+
+    // This should not throw an error
+    await expect(updateGitignore(nonExistentDir)).resolves.toBeUndefined();
+  });
+
+  it('handles permission errors gracefully', async () => {
+    const consoleSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+    const fsModule = await import('node:fs');
+    const writeFileSpy = vi
+      .spyOn(fsModule.promises, 'writeFile')
+      .mockRejectedValue(new Error('Permission denied'));
+
+    await expect(updateGitignore(scratchDir)).resolves.toBeUndefined();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Failed to update .gitignore:',
+      expect.any(Error),
+    );
+
+    writeFileSpy.mockRestore();
+    consoleSpy.mockRestore();
+  });
+});

projects/ui/qwen-code/packages/cli/src/ui/commands/setupGithubCommand.ts

@@ -0,0 +1,212 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+import * as fs from 'node:fs';
+import { Writable } from 'node:stream';
+import { ProxyAgent } from 'undici';
+
+import { CommandContext } from '../../ui/commands/types.js';
+import {
+  getGitRepoRoot,
+  getLatestGitHubRelease,
+  isGitHubRepository,
+  getGitHubRepoInfo,
+} from '../../utils/gitUtils.js';
+
+import {
+  CommandKind,
+  SlashCommand,
+  SlashCommandActionReturn,
+} from './types.js';
+import { getUrlOpenCommand } from '../../ui/utils/commandUtils.js';
+
+export const GITHUB_WORKFLOW_PATHS = [
+  'gemini-dispatch/gemini-dispatch.yml',
+  'gemini-assistant/gemini-invoke.yml',
+  'issue-triage/gemini-triage.yml',
+  'issue-triage/gemini-scheduled-triage.yml',
+  'pr-review/gemini-review.yml',
+];
+
+// Generate OS-specific commands to open the GitHub pages needed for setup.
+function getOpenUrlsCommands(readmeUrl: string): string[] {
+  // Determine the OS-specific command to open URLs, ex: 'open', 'xdg-open', etc
+  const openCmd = getUrlOpenCommand();
+
+  // Build a list of URLs to open
+  const urlsToOpen = [readmeUrl];
+
+  const repoInfo = getGitHubRepoInfo();
+  if (repoInfo) {
+    urlsToOpen.push(
+      `https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`,
+    );
+  }
+
+  // Create and join the individual commands
+  const commands = urlsToOpen.map((url) => `${openCmd} "${url}"`);
+  return commands;
+}
+
+// Add Gemini CLI specific entries to .gitignore file
+export async function updateGitignore(gitRepoRoot: string): Promise<void> {
+  const gitignoreEntries = ['.gemini/', 'gha-creds-*.json'];
+
+  const gitignorePath = path.join(gitRepoRoot, '.gitignore');
+  try {
+    // Check if .gitignore exists and read its content
+    let existingContent = '';
+    let fileExists = true;
+    try {
+      existingContent = await fs.promises.readFile(gitignorePath, 'utf8');
+    } catch (_error) {
+      // File doesn't exist
+      fileExists = false;
+    }
+
+    if (!fileExists) {
+      // Create new .gitignore file with the entries
+      const contentToWrite = gitignoreEntries.join('\n') + '\n';
+      await fs.promises.writeFile(gitignorePath, contentToWrite);
+    } else {
+      // Check which entries are missing
+      const missingEntries = gitignoreEntries.filter(
+        (entry) =>
+          !existingContent
+            .split(/\r?\n/)
+            .some((line) => line.split('#')[0].trim() === entry),
+      );
+
+      if (missingEntries.length > 0) {
+        const contentToAdd = '\n' + missingEntries.join('\n') + '\n';
+        await fs.promises.appendFile(gitignorePath, contentToAdd);
+      }
+    }
+  } catch (error) {
+    console.debug('Failed to update .gitignore:', error);
+    // Continue without failing the whole command
+  }
+}
+
+export const setupGithubCommand: SlashCommand = {
+  name: 'setup-github',
+  description: 'Set up GitHub Actions',
+  kind: CommandKind.BUILT_IN,
+  action: async (
+    context: CommandContext,
+  ): Promise<SlashCommandActionReturn> => {
+    const abortController = new AbortController();
+
+    if (!isGitHubRepository()) {
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
+    }
+
+    // Find the root directory of the repo
+    let gitRepoRoot: string;
+    try {
+      gitRepoRoot = getGitRepoRoot();
+    } catch (_error) {
+      console.debug(`Failed to get git repo root:`, _error);
+      throw new Error(
+        'Unable to determine the GitHub repository. /setup-github must be run from a git repository.',
+      );
+    }
+
+    // Get the latest release tag from GitHub
+    const proxy = context?.services?.config?.getProxy();
+    const releaseTag = await getLatestGitHubRelease(proxy);
+    const readmeUrl = `https://github.com/google-github-actions/run-gemini-cli/blob/${releaseTag}/README.md#quick-start`;
+
+    // Create the .github/workflows directory to download the files into
+    const githubWorkflowsDir = path.join(gitRepoRoot, '.github', 'workflows');
+    try {
+      await fs.promises.mkdir(githubWorkflowsDir, { recursive: true });
+    } catch (_error) {
+      console.debug(
+        `Failed to create ${githubWorkflowsDir} directory:`,
+        _error,
+      );
+      throw new Error(
+        `Unable to create ${githubWorkflowsDir} directory. Do you have file permissions in the current directory?`,
+      );
+    }
+
+    // Download each workflow in parallel - there aren't enough files to warrant
+    // a full workerpool model here.
+    const downloads = [];
+    for (const workflow of GITHUB_WORKFLOW_PATHS) {
+      downloads.push(
+        (async () => {
+          const endpoint = `https://raw.githubusercontent.com/google-github-actions/run-gemini-cli/refs/tags/${releaseTag}/examples/workflows/${workflow}`;
+          const response = await fetch(endpoint, {
+            method: 'GET',
+            dispatcher: proxy ? new ProxyAgent(proxy) : undefined,
+            signal: AbortSignal.any([
+              AbortSignal.timeout(30_000),
+              abortController.signal,
+            ]),
+          } as RequestInit);
+
+          if (!response.ok) {
+            throw new Error(
+              `Invalid response code downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+          const body = response.body;
+          if (!body) {
+            throw new Error(
+              `Empty body while downloading ${endpoint}: ${response.status} - ${response.statusText}`,
+            );
+          }
+
+          const destination = path.resolve(
+            githubWorkflowsDir,
+            path.basename(workflow),
+          );
+
+          const fileStream = fs.createWriteStream(destination, {
+            mode: 0o644, // -rw-r--r--, user(rw), group(r), other(r)
+            flags: 'w', // write and overwrite
+            flush: true,
+          });
+
+          await body.pipeTo(Writable.toWeb(fileStream));
+        })(),
+      );
+    }
+
+    // Wait for all downloads to complete
+    await Promise.all(downloads).finally(() => {
+      // Stop existing downloads
+      abortController.abort();
+    });
+
+    // Add entries to .gitignore file
+    await updateGitignore(gitRepoRoot);
+
+    // Print out a message
+    const commands = [];
+    commands.push('set -eEuo pipefail');
+    commands.push(
+      `echo "Successfully downloaded ${GITHUB_WORKFLOW_PATHS.length} workflows and updated .gitignore. Follow the steps in ${readmeUrl} (skipping the /setup-github step) to complete setup."`,
+    );
+    commands.push(...getOpenUrlsCommands(readmeUrl));
+
+    const command = `(${commands.join(' && ')})`;
+    return {
+      type: 'tool',
+      toolName: 'run_shell_command',
+      toolArgs: {
+        description:
+          'Setting up GitHub Actions to triage issues and review PRs with Gemini.',
+        command,
+      },
+    };
+  },
+};