@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/commands/mcp/enableDisable.js

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger } from '@google/gemini-cli-core';
+import { McpServerEnablementManager, canLoadServer, normalizeServerId, } from '../../config/mcp/mcpServerEnablement.js';
+import { loadSettings } from '../../config/settings.js';
+import { exitCli } from '../utils.js';
+import { getMcpServersFromConfig } from './list.js';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+async function handleEnable(args) {
+    const manager = McpServerEnablementManager.getInstance();
+    const name = normalizeServerId(args.name);
+    // Check settings blocks
+    const settings = loadSettings();
+    // Get all servers including extensions
+    const servers = await getMcpServersFromConfig();
+    const normalizedServerNames = Object.keys(servers).map(normalizeServerId);
+    if (!normalizedServerNames.includes(name)) {
+        debugLogger.log(`${RED}Error:${RESET} Server '${args.name}' not found. Use 'gemini mcp' to see available servers.`);
+        return;
+    }
+    const result = await canLoadServer(name, {
+        adminMcpEnabled: settings.merged.admin?.mcp?.enabled ?? true,
+        allowedList: settings.merged.mcp?.allowed,
+        excludedList: settings.merged.mcp?.excluded,
+    });
+    if (!result.allowed &&
+        (result.blockType === 'allowlist' || result.blockType === 'excludelist')) {
+        debugLogger.log(`${RED}Error:${RESET} ${result.reason}`);
+        return;
+    }
+    if (args.session) {
+        manager.clearSessionDisable(name);
+        debugLogger.log(`${GREEN}✓${RESET} Session disable cleared for '${name}'.`);
+    }
+    else {
+        await manager.enable(name);
+        debugLogger.log(`${GREEN}✓${RESET} MCP server '${name}' enabled.`);
+    }
+    if (result.blockType === 'admin') {
+        debugLogger.log(`${YELLOW}Warning:${RESET} MCP servers are disabled by administrator.`);
+    }
+}
+async function handleDisable(args) {
+    const manager = McpServerEnablementManager.getInstance();
+    const name = normalizeServerId(args.name);
+    // Get all servers including extensions
+    const servers = await getMcpServersFromConfig();
+    const normalizedServerNames = Object.keys(servers).map(normalizeServerId);
+    if (!normalizedServerNames.includes(name)) {
+        debugLogger.log(`${RED}Error:${RESET} Server '${args.name}' not found. Use 'gemini mcp' to see available servers.`);
+        return;
+    }
+    if (args.session) {
+        manager.disableForSession(name);
+        debugLogger.log(`${GREEN}✓${RESET} MCP server '${name}' disabled for this session.`);
+    }
+    else {
+        await manager.disable(name);
+        debugLogger.log(`${GREEN}✓${RESET} MCP server '${name}' disabled.`);
+    }
+}
+export const enableCommand = {
+    command: 'enable <name>',
+    describe: 'Enable an MCP server',
+    builder: (yargs) => yargs
+        .positional('name', {
+        describe: 'MCP server name to enable',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('session', {
+        describe: 'Clear session-only disable',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (argv) => {
+        await handleEnable(argv);
+        await exitCli();
+    },
+};
+export const disableCommand = {
+    command: 'disable <name>',
+    describe: 'Disable an MCP server',
+    builder: (yargs) => yargs
+        .positional('name', {
+        describe: 'MCP server name to disable',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('session', {
+        describe: 'Disable for current session only',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (argv) => {
+        await handleDisable(argv);
+        await exitCli();
+    },
+};

package/dist/commands/mcp/list.js

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadSettings, } from '../../config/settings.js';
+import { MCPServerStatus, createTransport, debugLogger, applyAdminAllowlist, getAdminBlockedMcpServersMessage, } from '@google/gemini-cli-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { ExtensionManager } from '../../config/extension-manager.js';
+import { canLoadServer, McpServerEnablementManager, } from '../../config/mcp/index.js';
+import { requestConsentNonInteractive } from '../../config/extensions/consent.js';
+import { promptForSetting } from '../../config/extensions/extensionSettings.js';
+import { exitCli } from '../utils.js';
+import chalk from 'chalk';
+export async function getMcpServersFromConfig(settings) {
+    if (!settings) {
+        settings = loadSettings().merged;
+    }
+    const extensionManager = new ExtensionManager({
+        settings,
+        workspaceDir: process.cwd(),
+        requestConsent: requestConsentNonInteractive,
+        requestSetting: promptForSetting,
+    });
+    const extensions = await extensionManager.loadExtensions();
+    const mcpServers = { ...settings.mcpServers };
+    for (const extension of extensions) {
+        Object.entries(extension.mcpServers || {}).forEach(([key, server]) => {
+            if (mcpServers[key]) {
+                return;
+            }
+            mcpServers[key] = {
+                // eslint-disable-next-line @typescript-eslint/no-misused-spread
+                ...server,
+                extension,
+            };
+        });
+    }
+    const adminAllowlist = settings.admin?.mcp?.config;
+    const filteredResult = applyAdminAllowlist(mcpServers, adminAllowlist);
+    return filteredResult;
+}
+const MCP_LIST_DEFAULT_TIMEOUT_MSEC = 5000;
+async function testMCPConnection(serverName, config, isTrusted, activeSettings) {
+    // SECURITY: Only test connection if workspace is trusted or if it's a remote server.
+    // stdio servers execute local commands and must never run in untrusted workspaces.
+    const isStdio = !!config.command;
+    if (isStdio && !isTrusted) {
+        return MCPServerStatus.DISCONNECTED;
+    }
+    const client = new Client({
+        name: 'mcp-test-client',
+        version: '0.0.1',
+    });
+    const mcpContext = {
+        sanitizationConfig: {
+            enableEnvironmentVariableRedaction: true,
+            allowedEnvironmentVariables: [],
+            blockedEnvironmentVariables: activeSettings.advanced.excludedEnvVars,
+        },
+        emitMcpDiagnostic: (severity, message, error, serverName) => {
+            // In non-interactive list, we log everything through debugLogger for consistency
+            if (severity === 'error') {
+                debugLogger.error(chalk.red(`Error${serverName ? ` (${serverName})` : ''}: ${message}`), error);
+            }
+            else if (severity === 'warning') {
+                debugLogger.warn(chalk.yellow(`Warning${serverName ? ` (${serverName})` : ''}: ${message}`), error);
+            }
+            else {
+                debugLogger.log(message, error);
+            }
+        },
+        isTrustedFolder: () => isTrusted,
+    };
+    let transport;
+    try {
+        // Use the same transport creation logic as core
+        transport = await createTransport(serverName, config, false, mcpContext);
+    }
+    catch {
+        await client.close();
+        return MCPServerStatus.DISCONNECTED;
+    }
+    try {
+        // Attempt actual MCP connection with timeout from config or default to 5s.
+        // We use a short default for the list command to keep it responsive.
+        const timeout = config.timeout ?? MCP_LIST_DEFAULT_TIMEOUT_MSEC;
+        await client.connect(transport, { timeout });
+        // Test basic MCP protocol by pinging the server.
+        // Ping is optional per MCP spec - some servers (e.g. Google first-party)
+        // don't implement it. A successful connect() is sufficient proof of connectivity.
+        try {
+            await client.ping({ timeout });
+        }
+        catch (e) {
+            debugLogger.debug(`MCP ping failed for ${serverName}, but connect succeeded:`, e);
+        }
+        await client.close();
+        return MCPServerStatus.CONNECTED;
+    }
+    catch {
+        await transport.close();
+        return MCPServerStatus.DISCONNECTED;
+    }
+}
+async function getServerStatus(serverName, server, isTrusted, activeSettings, consolidatedExcluded, consolidatedAllowed) {
+    const mcpEnablementManager = McpServerEnablementManager.getInstance();
+    const loadResult = await canLoadServer(serverName, {
+        adminMcpEnabled: activeSettings.admin?.mcp?.enabled ?? true,
+        allowedList: consolidatedAllowed,
+        excludedList: consolidatedExcluded.length > 0 ? consolidatedExcluded : undefined,
+        enablement: mcpEnablementManager.getEnablementCallbacks(),
+    });
+    if (!loadResult.allowed) {
+        if (loadResult.blockType === 'admin' ||
+            loadResult.blockType === 'allowlist' ||
+            loadResult.blockType === 'excludelist') {
+            return MCPServerStatus.BLOCKED;
+        }
+        return MCPServerStatus.DISABLED;
+    }
+    if (!isTrusted) {
+        return MCPServerStatus.DISABLED;
+    }
+    // Test all server types by attempting actual connection
+    return testMCPConnection(serverName, server, isTrusted, activeSettings);
+}
+export async function listMcpServers(loadedSettingsArg) {
+    const loadedSettings = loadedSettingsArg ?? loadSettings();
+    const activeSettings = loadedSettings.merged;
+    // If the folder is untrusted, we want to show all configured servers (including
+    // project-scoped ones) as disabled.
+    const allSettings = !loadedSettings.isTrusted
+        ? loadedSettings.getMergedSettingsAsIfTrusted()
+        : activeSettings;
+    const { mcpServers, blockedServerNames } = await getMcpServersFromConfig(allSettings);
+    const serverNames = Object.keys(mcpServers);
+    if (blockedServerNames.length > 0) {
+        const message = getAdminBlockedMcpServersMessage(blockedServerNames, undefined);
+        debugLogger.log(chalk.yellow(message + '\n'));
+    }
+    if (serverNames.length === 0) {
+        if (blockedServerNames.length === 0) {
+            debugLogger.log('No MCP servers configured.');
+        }
+        return;
+    }
+    if (!loadedSettings.isTrusted) {
+        debugLogger.log(chalk.yellow('Warning: MCP servers are configured but disabled because this folder is untrusted.\n' +
+            'User-level servers are also suppressed in untrusted folders to prevent accidental side-effects.\n'));
+    }
+    const consolidatedExcluded = loadedSettings.getConsolidatedExcludedMcpServers();
+    const consolidatedAllowed = loadedSettings.getConsolidatedAllowedMcpServers();
+    debugLogger.log('Configured MCP servers:\n');
+    for (const serverName of serverNames) {
+        const server = mcpServers[serverName];
+        const status = await getServerStatus(serverName, server, loadedSettings.isTrusted, activeSettings, consolidatedExcluded, consolidatedAllowed);
+        let statusIndicator = '';
+        let statusText = '';
+        switch (status) {
+            case MCPServerStatus.CONNECTED:
+                statusIndicator = chalk.green('✓');
+                statusText = 'Connected';
+                break;
+            case MCPServerStatus.CONNECTING:
+                statusIndicator = chalk.yellow('…');
+                statusText = 'Connecting';
+                break;
+            case MCPServerStatus.BLOCKED:
+                statusIndicator = chalk.red('⛔');
+                statusText = 'Blocked';
+                break;
+            case MCPServerStatus.DISABLED:
+                statusIndicator = chalk.gray('○');
+                statusText = 'Disabled';
+                break;
+            case MCPServerStatus.DISCONNECTED:
+            default:
+                statusIndicator = chalk.red('✗');
+                statusText = 'Disconnected';
+                break;
+        }
+        let serverInfo = serverName +
+            (server.extension?.name ? ` (from ${server.extension.name})` : '') +
+            ': ';
+        if (server.httpUrl) {
+            serverInfo += `${server.httpUrl} (http)`;
+        }
+        else if (server.url) {
+            const type = server.type || 'http';
+            serverInfo += `${server.url} (${type})`;
+        }
+        else if (server.command) {
+            serverInfo += `${server.command} ${server.args?.join(' ') || ''} (stdio)`;
+        }
+        debugLogger.log(`${statusIndicator} ${serverInfo} - ${statusText}`);
+    }
+}
+export const listCommand = {
+    command: 'list',
+    describe: 'List all configured MCP servers',
+    handler: async (argv) => {
+        await listMcpServers(argv.loadedSettings);
+        await exitCli();
+    },
+};

package/dist/commands/mcp/remove.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadSettings, SettingScope } from '../../config/settings.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { exitCli } from '../utils.js';
+async function removeMcpServer(name, options) {
+    const { scope } = options;
+    const settingsScope = scope === 'user' ? SettingScope.User : SettingScope.Workspace;
+    const settings = loadSettings();
+    const existingSettings = settings.forScope(settingsScope).settings;
+    const mcpServers = existingSettings.mcpServers || {};
+    if (!mcpServers[name]) {
+        debugLogger.log(`Server "${name}" not found in ${scope} settings.`);
+        return;
+    }
+    delete mcpServers[name];
+    settings.setValue(settingsScope, 'mcpServers', mcpServers);
+    debugLogger.log(`Server "${name}" removed from ${scope} settings.`);
+}
+export const removeCommand = {
+    command: 'remove <name>',
+    describe: 'Remove a server',
+    builder: (yargs) => yargs
+        .usage('Usage: gemini mcp remove [options] <name>')
+        .positional('name', {
+        describe: 'Name of the server',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('scope', {
+        alias: 's',
+        describe: 'Configuration scope (user or project)',
+        type: 'string',
+        default: 'project',
+        choices: ['user', 'project'],
+    }),
+    handler: async (argv) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        await removeMcpServer(argv['name'], {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            scope: argv['scope'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/mcp.js

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { addCommand } from './mcp/add.js';
+import { removeCommand } from './mcp/remove.js';
+import { listCommand } from './mcp/list.js';
+import { enableCommand, disableCommand } from './mcp/enableDisable.js';
+import { initializeOutputListenersAndFlush } from '../gemini.js';
+import { defer } from '../deferred.js';
+export const mcpCommand = {
+    command: 'mcp',
+    describe: 'Manage MCP servers',
+    builder: (yargs) => yargs
+        .middleware((argv) => {
+        initializeOutputListenersAndFlush();
+        argv['isCommand'] = true;
+    })
+        .command(defer(addCommand, 'mcp'))
+        .command(defer(removeCommand, 'mcp'))
+        .command(defer(listCommand, 'mcp'))
+        .command(defer(enableCommand, 'mcp'))
+        .command(defer(disableCommand, 'mcp'))
+        .demandCommand(1, 'You need at least one command before continuing.')
+        .version(false),
+    handler: () => {
+        // yargs will automatically show help if no subcommand is provided
+        // thanks to demandCommand(1) in the builder.
+    },
+};

package/dist/commands/skills/disable.js

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadSettings, SettingScope } from '../../config/settings.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { exitCli } from '../utils.js';
+import { disableSkill } from '../../utils/skillSettings.js';
+import { renderSkillActionFeedback } from '../../utils/skillUtils.js';
+import chalk from 'chalk';
+export async function handleDisable(args) {
+    const { name, scope } = args;
+    const workspaceDir = process.cwd();
+    const settings = loadSettings(workspaceDir);
+    const result = disableSkill(settings, name, scope);
+    const feedback = renderSkillActionFeedback(result, (label, path) => `${chalk.bold(label)} (${chalk.dim(path)})`);
+    debugLogger.log(feedback);
+}
+export const disableCommand = {
+    command: 'disable <name> [--scope]',
+    describe: 'Disables an agent skill.',
+    builder: (yargs) => yargs
+        .positional('name', {
+        describe: 'The name of the skill to disable.',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('scope', {
+        alias: 's',
+        describe: 'The scope to disable the skill in (user or workspace).',
+        type: 'string',
+        default: 'workspace',
+        choices: ['user', 'workspace'],
+    }),
+    handler: async (argv) => {
+        const scope = argv['scope'] === 'workspace'
+            ? SettingScope.Workspace
+            : SettingScope.User;
+        await handleDisable({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            name: argv['name'],
+            scope,
+        });
+        await exitCli();
+    },
+};

package/dist/commands/skills/enable.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadSettings } from '../../config/settings.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { exitCli } from '../utils.js';
+import { enableSkill } from '../../utils/skillSettings.js';
+import { renderSkillActionFeedback } from '../../utils/skillUtils.js';
+import chalk from 'chalk';
+export async function handleEnable(args) {
+    const { name } = args;
+    const workspaceDir = process.cwd();
+    const settings = loadSettings(workspaceDir);
+    const result = enableSkill(settings, name);
+    const feedback = renderSkillActionFeedback(result, (label, path) => `${chalk.bold(label)} (${chalk.dim(path)})`);
+    debugLogger.log(feedback);
+}
+export const enableCommand = {
+    command: 'enable <name>',
+    describe: 'Enables an agent skill.',
+    builder: (yargs) => yargs.positional('name', {
+        describe: 'The name of the skill to enable.',
+        type: 'string',
+        demandOption: true,
+    }),
+    handler: async (argv) => {
+        await handleEnable({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            name: argv['name'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/skills/install.js

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, getErrorMessage, } from '@google/gemini-cli-core';
+import { exitCli } from '../utils.js';
+import { installSkill } from '../../utils/skillUtils.js';
+import chalk from 'chalk';
+import { requestConsentNonInteractive, skillsConsentString, } from '../../config/extensions/consent.js';
+export async function handleInstall(args) {
+    try {
+        const { source, consent } = args;
+        const scope = args.scope ?? 'user';
+        const subpath = args.path;
+        const requestConsent = async (skills, targetDir) => {
+            if (consent) {
+                debugLogger.log('You have consented to the following:');
+                debugLogger.log(await skillsConsentString(skills, source, targetDir));
+                return true;
+            }
+            return requestConsentNonInteractive(await skillsConsentString(skills, source, targetDir));
+        };
+        const installedSkills = await installSkill(source, scope, subpath, (msg) => {
+            debugLogger.log(msg);
+        }, requestConsent);
+        for (const skill of installedSkills) {
+            debugLogger.log(chalk.green(`Successfully installed skill: ${chalk.bold(skill.name)} (scope: ${scope}, location: ${skill.location})`));
+        }
+    }
+    catch (error) {
+        debugLogger.error(getErrorMessage(error));
+        await exitCli(1);
+    }
+}
+export const installCommand = {
+    command: 'install <source> [--scope] [--path]',
+    describe: 'Installs an agent skill from a git repository URL or a local path.',
+    builder: (yargs) => yargs
+        .positional('source', {
+        describe: 'The git repository URL or local path of the skill to install.',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('scope', {
+        describe: 'The scope to install the skill into. Defaults to "user" (global).',
+        choices: ['user', 'workspace'],
+        default: 'user',
+    })
+        .option('path', {
+        describe: 'Sub-path within the repository to install from (only used for git repository sources).',
+        type: 'string',
+    })
+        .option('consent', {
+        describe: 'Acknowledge the security risks of installing a skill and skip the confirmation prompt.',
+        type: 'boolean',
+        default: false,
+    })
+        .check((argv) => {
+        if (!argv.source) {
+            throw new Error('The source argument must be provided.');
+        }
+        return true;
+    }),
+    handler: async (argv) => {
+        await handleInstall({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            source: argv['source'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            scope: argv['scope'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            path: argv['path'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            consent: argv['consent'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/skills/link.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debugLogger, getErrorMessage } from '@google/gemini-cli-core';
+import chalk from 'chalk';
+import { exitCli } from '../utils.js';
+import { requestConsentNonInteractive, skillsConsentString, } from '../../config/extensions/consent.js';
+import { linkSkill } from '../../utils/skillUtils.js';
+export async function handleLink(args) {
+    try {
+        const { scope = 'user', consent } = args;
+        await linkSkill(args.path, scope, (msg) => debugLogger.log(msg), async (skills, targetDir) => {
+            const consentString = await skillsConsentString(skills, args.path, targetDir, true);
+            if (consent) {
+                debugLogger.log('You have consented to the following:');
+                debugLogger.log(consentString);
+                return true;
+            }
+            return requestConsentNonInteractive(consentString);
+        });
+        debugLogger.log(chalk.green('\nSuccessfully linked skills.'));
+    }
+    catch (error) {
+        debugLogger.error(getErrorMessage(error));
+        await exitCli(1);
+    }
+}
+export const linkCommand = {
+    command: 'link <path>',
+    describe: 'Links an agent skill from a local path. Updates to the source will be reflected immediately.',
+    builder: (yargs) => yargs
+        .positional('path', {
+        describe: 'The local path of the skill to link.',
+        type: 'string',
+        demandOption: true,
+    })
+        .option('scope', {
+        describe: 'The scope to link the skill into. Defaults to "user" (global).',
+        choices: ['user', 'workspace'],
+        default: 'user',
+    })
+        .option('consent', {
+        describe: 'Acknowledge the security risks of linking a skill and skip the confirmation prompt.',
+        type: 'boolean',
+        default: false,
+    })
+        .check((argv) => {
+        if (!argv.path) {
+            throw new Error('The path argument must be provided.');
+        }
+        return true;
+    }),
+    handler: async (argv) => {
+        await handleLink({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            path: argv['path'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            scope: argv['scope'],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            consent: argv['consent'],
+        });
+        await exitCli();
+    },
+};

package/dist/commands/skills/list.js

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { loadSettings } from '../../config/settings.js';
+import { loadCliConfig } from '../../config/config.js';
+import { exitCli } from '../utils.js';
+import chalk from 'chalk';
+export async function handleList(args) {
+    const workspaceDir = process.cwd();
+    const settings = loadSettings(workspaceDir);
+    const config = await loadCliConfig(settings.merged, 'skills-list-session', 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    {
+        debug: false,
+    }, { cwd: workspaceDir });
+    // Initialize to trigger extension loading and skill discovery
+    await config.initialize();
+    const skillManager = config.getSkillManager();
+    const skills = args.all
+        ? skillManager.getAllSkills()
+        : skillManager.getAllSkills().filter((s) => !s.isBuiltin);
+    // Sort skills: non-built-in first, then alphabetically by name
+    skills.sort((a, b) => {
+        if (a.isBuiltin === b.isBuiltin) {
+            return a.name.localeCompare(b.name);
+        }
+        return a.isBuiltin ? 1 : -1;
+    });
+    if (skills.length === 0) {
+        process.stdout.write('No skills discovered.\n');
+        return;
+    }
+    process.stdout.write(chalk.bold('Discovered Agent Skills:') + '\n\n');
+    for (const skill of skills) {
+        const status = skill.disabled
+            ? chalk.red('[Disabled]')
+            : chalk.green('[Enabled]');
+        const builtinSuffix = skill.isBuiltin ? chalk.gray(' [Built-in]') : '';
+        process.stdout.write(`${chalk.bold(skill.name)} ${status}${builtinSuffix}\n`);
+        process.stdout.write(`  Description: ${skill.description}\n`);
+        process.stdout.write(`  Location:    ${skill.location}\n\n`);
+    }
+}
+export const listCommand = {
+    command: 'list [--all]',
+    describe: 'Lists discovered agent skills.',
+    builder: (yargs) => yargs.option('all', {
+        type: 'boolean',
+        description: 'Show all skills, including built-in ones.',
+        default: false,
+    }),
+    handler: async (argv) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        await handleList({ all: argv['all'] });
+        await exitCli();
+    },
+};