@xagent-ai/cli 1.2.2 → 1.3.0

package/dist/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { confirm } from '@clack/prompts';
 import { startInteractiveSession } from './session.js';
 import { getConfigManager } from './config.js';
 import { AuthService, selectAuthType } from './auth.js';
+import { AuthType } from './types.js';
+import { fetchDefaultModels } from './ai-client/providers/remote.js';
 import { getAgentManager } from './agents.js';
 import { getMCPManager } from './mcp.js';
 import { getLogger, setConfigProvider } from './logger.js';
@@ -15,6 +18,23 @@ import { fileURLToPath } from 'url';
 // Get current directory
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+// State file for skill updates (used to notify running xAgent)
+const SKILL_STATE_FILE = '.skill-state.json';
+function getSkillStateFilePath(userSkillsPath) {
+    return path.join(userSkillsPath, SKILL_STATE_FILE);
+}
+async function notifySkillUpdate(userSkillsPath) {
+    try {
+        const stateFilePath = getSkillStateFilePath(userSkillsPath);
+        const timestamp = Date.now();
+        const state = { lastSkillUpdate: timestamp };
+        await fs.writeFile(stateFilePath, JSON.stringify(state, null, 2), 'utf-8');
+        console.log(colors.textMuted('  ℹ️  Skills updated for running xAgent sessions'));
+    }
+    catch (error) {
+        // Silent fail - notification is optional
+    }
+}
 // Read package.json
 const packageJsonPath = join(__dirname, '../package.json');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
@@ -82,12 +102,39 @@ function formatError(error) {
             suggestion: 'The configuration file may be corrupted. Please check the file content.'
         };
     }
+    // User cancellation - no suggestion needed
+    if (errorMessage.includes('cancelled by user') || errorMessage.includes('Operation cancelled')) {
+        return {
+            message: 'Operation cancelled',
+            suggestion: ''
+        };
+    }
     // Default friendly message
     return {
         message: 'An error occurred',
         suggestion: 'Please try again. If the problem persists, check your configuration.'
     };
 }
+/**
+ * Recursively copy a directory
+ */
+async function copyDirectory(src, dest) {
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    await fs.mkdir(dest, { recursive: true });
+    for (const entry of entries) {
+        // Skip node_modules to keep dependencies isolated
+        // if (entry.name === 'node_modules') continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            await fs.copyFile(srcPath, destPath);
+        }
+        // Skip symbolic links for simplicity
+    }
+}
 program
     .name('xagent')
     .description('AI-powered command-line assistant')
@@ -111,7 +158,7 @@ program
             process.exit(1);
         }
         configManager.setApprovalMode(options.approvalMode);
-        await configManager.save('global');
+        configManager.save('global');
         console.log('');
         console.log(colors.success(`✅ Approval mode set to: ${options.approvalMode}`));
         console.log('');
@@ -130,16 +177,48 @@ program
     const authType = await selectAuthType();
     const configManager = getConfigManager();
     configManager.set('selectedAuthType', authType);
+    // Get xagentApiBaseUrl from config (respects XAGENT_BASE_URL env var)
+    const config = configManager.getAuthConfig();
     const authService = new AuthService({
         type: authType,
         apiKey: '',
         baseUrl: '',
-        modelName: ''
+        modelName: '',
+        xagentApiBaseUrl: config.xagentApiBaseUrl
     });
     const success = await authService.authenticate();
     if (success) {
         const authConfig = authService.getAuthConfig();
-        await configManager.setAuthConfig(authConfig);
+        // Clear modelName for remote mode
+        if (authType === AuthType.OAUTH_XAGENT) {
+            authConfig.modelName = '';
+        }
+        configManager.setAuthConfig(authConfig);
+        // Set default remote model settings if not already set
+        if (authType === AuthType.OAUTH_XAGENT) {
+            const webBaseUrl = authConfig.xagentApiBaseUrl || 'https://www.xagent-colife.net';
+            let defaultLlmName = '';
+            let defaultVlmName = '';
+            try {
+                console.log(colors.textMuted('   Fetching default models from remote server...'));
+                const defaults = await fetchDefaultModels(authConfig.apiKey || '', webBaseUrl);
+                if (defaults.llm?.name) {
+                    defaultLlmName = defaults.llm.name;
+                    console.log(colors.textMuted(`   Default LLM: ${defaults.llm.displayName || defaultLlmName}`));
+                }
+                if (defaults.vlm?.name) {
+                    defaultVlmName = defaults.vlm.name;
+                    console.log(colors.textMuted(`   Default VLM: ${defaults.vlm.displayName || defaultVlmName}`));
+                }
+            }
+            catch (error) {
+                console.log(colors.textMuted(`   ⚠️  Failed to fetch default models: ${error.message}`));
+                console.log(colors.textMuted('   ⚠️  Use /model command to select models manually.'));
+            }
+            configManager.set('remote_llmModelName', defaultLlmName);
+            configManager.set('remote_vlmModelName', defaultVlmName);
+            configManager.save('global');
+        }
         console.log('');
         console.log(colors.success('Authentication configured successfully!'));
         console.log(colors.textMuted('You can now run "xagent start" to begin'));
@@ -215,9 +294,16 @@ program
     .command('mcp')
     .description('Add, list, or remove MCP servers')
     .option('-l, --list', 'List all MCP servers')
-    .option('-a, --add <name>', 'Add a new MCP server')
+    .option('-a, --add [name]', 'Add a new MCP server (interactive if no name provided)')
     .option('-r, --remove <name>', 'Remove an MCP server')
     .option('--scope <scope>', 'Scope (global or project)', 'global')
+    .option('-t, --transport <type>', 'Transport type: stdio, http')
+    .option('-c, --command <cmd>', 'Command for stdio transport')
+    .option('--args <args>', 'Arguments for stdio transport (comma-separated)')
+    .option('-u, --url <url>', 'URL for HTTP transport')
+    .option('-k, --token <token>', 'Authentication token (Bearer)')
+    .option('--header <headers>', 'Custom headers (can be used multiple times)')
+    .option('-y, --yes', 'Skip confirmation')
     .action(async (options) => {
     const configManager = getConfigManager(process.cwd());
     const mcpManager = getMCPManager();
@@ -226,7 +312,7 @@ program
         if (servers.length === 0) {
             console.log('');
             console.log(colors.warning('No MCP servers configured'));
-            console.log(colors.textMuted('Use /mcp add in interactive mode to add servers'));
+            console.log(colors.textMuted('Use "xagent mcp --add" to add servers'));
             console.log('');
         }
         else {
@@ -245,18 +331,271 @@ program
             });
         }
     }
-    else if (options.add) {
-        console.log('');
-        console.log(colors.warning('MCP server addition not implemented yet'));
-        console.log(colors.textMuted('Use /mcp add in interactive mode'));
-        console.log('');
+    else if (options.add !== undefined) {
+        // Check if running in non-interactive mode (transport and required params provided)
+        const hasTransport = options.transport;
+        const hasCommand = options.command;
+        const hasUrl = options.url;
+        const isNonInteractive = hasTransport && (hasCommand || hasUrl);
+        if (isNonInteractive) {
+            // Non-interactive mode: use command line arguments
+            const name = options.add || `mcp-${options.transport}-${Date.now().toString(36)}`;
+            const transport = options.transport;
+            const config = {
+                transport: transport,
+            };
+            if (transport === 'stdio') {
+                if (!options.command) {
+                    console.log('');
+                    console.log(colors.error('Error: --command is required for stdio transport'));
+                    console.log('');
+                    process.exit(1);
+                }
+                config.command = options.command;
+                if (options.args) {
+                    config.args = options.args.split(',').map((a) => a.trim());
+                }
+            }
+            else if (transport === 'http') {
+                if (!options.url) {
+                    console.log('');
+                    console.log(colors.error('Error: --url is required for http transport'));
+                    console.log('');
+                    process.exit(1);
+                }
+                config.url = options.url;
+                if (options.token) {
+                    config.authToken = options.token;
+                }
+                // Handle multiple --header flags
+                if (options.header) {
+                    const headers = {};
+                    const headerArray = Array.isArray(options.header) ? options.header : [options.header];
+                    for (const h of headerArray) {
+                        const colonIndex = h.indexOf(':');
+                        if (colonIndex > 0) {
+                            const key = h.substring(0, colonIndex).trim();
+                            const value = h.substring(colonIndex + 1).trim();
+                            headers[key] = value;
+                        }
+                    }
+                    if (Object.keys(headers).length > 0) {
+                        config.headers = headers;
+                    }
+                }
+            }
+            else {
+                console.log('');
+                console.log(colors.error(`Error: Unknown transport type: ${transport}`));
+                console.log(colors.textMuted('Valid types: stdio, http'));
+                console.log('');
+                process.exit(1);
+            }
+            // Skip confirmation in non-interactive mode
+            if (!options.yes) {
+                console.log('');
+                console.log(colors.textMuted('Server configuration:'));
+                console.log(`  ${colors.primaryBright('Name:')} ${name}`);
+                console.log(`  ${colors.primaryBright('Transport:')} ${config.transport}`);
+                if (config.command) {
+                    console.log(`  ${colors.primaryBright('Command:')} ${config.command} ${(config.args || []).join(' ')}`);
+                }
+                if (config.url) {
+                    console.log(`  ${colors.primaryBright('URL:')} ${config.url}`);
+                    if (config.authToken) {
+                        console.log(`  ${colors.primaryBright('Token:')} [hidden]`);
+                    }
+                }
+                console.log('');
+            }
+            try {
+                // Save to config
+                configManager.addMcpServer(name, config);
+                configManager.save(options.scope);
+                // Register with MCP manager
+                mcpManager.registerServer(name, config);
+                // Try to connect
+                let connected = false;
+                try {
+                    await mcpManager.connectServer(name);
+                    connected = true;
+                }
+                catch (error) {
+                    console.log(colors.textMuted(`  ⚠️  Connection failed: ${error.message}`));
+                    console.log(colors.textMuted('  The server is saved but not connected.'));
+                }
+                if (connected) {
+                    console.log('');
+                    console.log(colors.success(`✅ MCP server '${name}' added and connected successfully`));
+                }
+                else {
+                    console.log('');
+                    console.log(colors.success(`✅ MCP server '${name}' added successfully`));
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.log('');
+                console.log(colors.error(`Failed to add MCP server: ${error.message}`));
+                console.log('');
+            }
+        }
+        else {
+            // Interactive mode
+            const { text, select, confirm } = await import('@clack/prompts');
+            const separator = icons.separator.repeat(40);
+            console.log('');
+            console.log(colors.primaryBright(`${icons.tool} Add MCP Server`));
+            console.log(colors.border(separator));
+            console.log('');
+            // Step 1: Enter server name
+            let name = options.add;
+            if (!name) {
+                name = await text({
+                    message: 'Enter MCP server name:',
+                    validate: (value) => {
+                        if (!value || !value.trim()) {
+                            return 'Server name is required';
+                        }
+                        if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+                            return 'Server name must contain only alphanumeric characters, hyphens, and underscores';
+                        }
+                        return undefined;
+                    },
+                });
+            }
+            // Step 2: Select transport type
+            const transport = await select({
+                message: 'Select transport type:',
+                options: [
+                    { value: 'stdio', label: 'Stdio (stdin/stdout)' },
+                    { value: 'http', label: 'HTTP (Streamable HTTP)' },
+                ],
+            });
+            if (typeof transport === 'symbol') {
+                console.log('');
+                console.log(colors.textMuted('Cancelled'));
+                console.log('');
+                return;
+            }
+            const config = {
+                transport: transport,
+            };
+            if (transport === 'stdio') {
+                // Step 3: Enter command
+                config.command = await text({
+                    message: 'Enter command (for stdio transport):',
+                    validate: (value) => value && value.trim() ? undefined : 'Command is required',
+                });
+                // Step 4: Enter arguments
+                const argsInput = await text({
+                    message: 'Enter arguments (comma-separated, for stdio transport):',
+                    defaultValue: '',
+                });
+                if (argsInput.trim()) {
+                    config.args = argsInput.split(',').map((a) => a.trim());
+                }
+            }
+            else {
+                // Step 3: Enter URL
+                let url = '';
+                while (!url) {
+                    url = await text({
+                        message: 'Enter server URL (for HTTP transport):',
+                        validate: (value) => {
+                            if (!value || !value.trim()) {
+                                return 'URL is required';
+                            }
+                            try {
+                                new URL(value);
+                                return undefined;
+                            }
+                            catch {
+                                return 'Invalid URL format (e.g., https://example.com)';
+                            }
+                        },
+                    });
+                }
+                config.url = url;
+                // Step 4: Enter auth token (optional)
+                config.authToken = await text({
+                    message: 'Enter Bearer token (optional):',
+                    defaultValue: '',
+                });
+                // Step 5: Enter custom headers (optional)
+                const headersInput = await text({
+                    message: 'Enter custom headers as JSON (optional):',
+                    defaultValue: '',
+                });
+                if (headersInput.trim()) {
+                    try {
+                        config.headers = JSON.parse(headersInput);
+                    }
+                    catch {
+                        // Ignore invalid JSON
+                    }
+                }
+            }
+            // Step 6: Confirm and save
+            console.log('');
+            console.log(colors.textMuted('Server configuration:'));
+            console.log(`  ${colors.primaryBright('Name:')} ${name}`);
+            console.log(`  ${colors.primaryBright('Transport:')} ${config.transport}`);
+            if (config.command) {
+                console.log(`  ${colors.primaryBright('Command:')} ${config.command} ${(config.args || []).join(' ')}`);
+            }
+            if (config.url) {
+                console.log(`  ${colors.primaryBright('URL:')} ${config.url}`);
+            }
+            console.log('');
+            const shouldSave = await confirm({
+                message: 'Save this MCP server configuration?',
+            });
+            if (typeof shouldSave === 'symbol' || !shouldSave) {
+                console.log('');
+                console.log(colors.textMuted('Cancelled'));
+                console.log('');
+                return;
+            }
+            try {
+                // Save to config
+                configManager.addMcpServer(name, config);
+                configManager.save(options.scope);
+                // Register with MCP manager
+                mcpManager.registerServer(name, config);
+                // Try to connect
+                let connected = false;
+                try {
+                    await mcpManager.connectServer(name);
+                    connected = true;
+                }
+                catch (error) {
+                    console.log(colors.textMuted(`  ⚠️  Connection failed: ${error.message}`));
+                    console.log(colors.textMuted('  The server is saved but not connected. Use "/mcp refresh" in interactive mode to retry.'));
+                }
+                if (connected) {
+                    console.log('');
+                    console.log(colors.success(`✅ MCP server '${name}' added and connected successfully`));
+                }
+                else {
+                    console.log('');
+                    console.log(colors.success(`✅ MCP server '${name}' added successfully (not connected)`));
+                }
+                console.log('');
+            }
+            catch (error) {
+                console.log('');
+                console.log(colors.error(`Failed to add MCP server: ${error.message}`));
+                console.log('');
+            }
+        }
     }
     else if (options.remove) {
         try {
             mcpManager.disconnectServer(options.remove);
             const mcpServers = configManager.getMcpServers();
             delete mcpServers[options.remove];
-            await configManager.save(options.scope);
+            configManager.save(options.scope);
             console.log('');
             console.log(colors.success(`MCP server ${options.remove} removed successfully`));
             console.log('');
@@ -273,6 +612,23 @@ program
         console.log('');
         console.log(colors.warning('Please specify an action: --list, --add, or --remove'));
         console.log('');
+        console.log(colors.textMuted('Usage:'));
+        console.log(`  ${colors.primaryBright('xagent mcp --list')}                    ${colors.textMuted('| List all MCP servers')}`);
+        console.log(`  ${colors.primaryBright('xagent mcp --add')}                     ${colors.textMuted('| Add MCP server (interactive)')}`);
+        console.log('');
+        console.log(colors.textMuted('Non-interactive examples:'));
+        console.log(`  ${colors.primaryBright('xagent mcp --add -t stdio -c "npx" --args "-y,@modelcontextprotocol/server-github"')}`);
+        console.log(`  ${colors.primaryBright('xagent mcp --add -t http -u "https://example.com/mcp" -k "token"')}`);
+        console.log('');
+        console.log(colors.textMuted('Options:'));
+        console.log(`  ${colors.primaryBright('-t, --transport')}   ${colors.textMuted('Transport: stdio or http')}`);
+        console.log(`  ${colors.primaryBright('-c, --command')}    ${colors.textMuted('Command for stdio transport')}`);
+        console.log(`  ${colors.primaryBright('--args')}          ${colors.textMuted('Arguments (comma-separated)')}`);
+        console.log(`  ${colors.primaryBright('-u, --url')}       ${colors.textMuted('URL for HTTP transport')}`);
+        console.log(`  ${colors.primaryBright('-k, --token')}     ${colors.textMuted('Bearer authentication token')}`);
+        console.log(`  ${colors.primaryBright('--header')}        ${colors.textMuted('Custom header (key:value)')}`);
+        console.log(`  ${colors.primaryBright('-y, --yes')}       ${colors.textMuted('Skip confirmation')}`);
+        console.log('');
     }
 });
 program
@@ -370,6 +726,213 @@ program
         console.log('');
     }
 });
+program
+    .command('skill')
+    .description('Manage skills')
+    .option('-l, --list', 'List all installed user skills')
+    .option('--add <source>', 'Install a skill (auto-detects local path or remote URL)')
+    .option('-r, --remove <skill-id>', 'Remove a user-installed skill')
+    .action(async (options) => {
+    const { getConfigManager } = await import('./config.js');
+    const configManager = getConfigManager();
+    const { promises: fs } = await import('fs');
+    const pathModule = await import('path');
+    const { exec, spawn } = await import('child_process');
+    const { promisify } = await import('util');
+    const os = await import('os');
+    const execAsync = promisify(exec);
+    const userSkillsPath = configManager.getUserSkillsPath() || pathModule.join(os.homedir(), '.xagent', 'skills');
+    const userNodeModulesPath = configManager.getUserNodeModulesPath() || pathModule.join(os.homedir(), '.xagent', 'node_modules');
+    if (options.add) {
+        const separator = icons.separator.repeat(40);
+        console.log('');
+        console.log(colors.primaryBright(`${icons.tool} Install Skill`));
+        console.log(colors.border(separator));
+        console.log('');
+        const source = options.add.trim();
+        const { installSkill } = await import('./skill-installer.js');
+        const { parseSource } = await import('./skill-installer.js');
+        // Auto-detect if source is local or remote
+        const parsed = parseSource(source);
+        const isLocal = parsed.type === 'local';
+        if (isLocal) {
+            // Local installation
+            const sourcePath = pathModule.resolve(source);
+            const skillName = pathModule.basename(sourcePath);
+            const destPath = pathModule.join(userSkillsPath, skillName);
+            try {
+                // Check if source exists
+                await fs.access(sourcePath);
+                // Check if SKILL.md exists
+                const skillMdPath = pathModule.join(sourcePath, 'SKILL.md');
+                try {
+                    await fs.access(skillMdPath);
+                }
+                catch {
+                    console.log(colors.error(`SKILL.md not found in ${sourcePath}`));
+                    console.log(colors.textMuted('Each skill must have a SKILL.md file'));
+                    console.log('');
+                    process.exit(1);
+                }
+                // Check if skill already exists in user skills path
+                try {
+                    await fs.access(destPath);
+                    console.log(colors.warning(`Skill "${skillName}" already installed`));
+                    console.log(colors.textMuted(`Use "xagent skill -r ${skillName}" to remove it first`));
+                    console.log('');
+                    process.exit(1);
+                }
+                catch {
+                    // Doesn't exist, proceed
+                }
+                // Ensure user skills directory exists
+                await fs.mkdir(userSkillsPath, { recursive: true });
+                // Copy the skill
+                await copyDirectory(sourcePath, destPath);
+                console.log('');
+                console.log(colors.success(`✅ Skill "${skillName}" installed successfully`));
+                console.log(colors.textMuted(`  Location: ${destPath}`));
+                console.log(colors.textMuted(`  Type: Local`));
+                console.log('');
+                // Notify running xAgent to update system prompt
+                await notifySkillUpdate(userSkillsPath);
+                console.log('');
+            }
+            catch (error) {
+                const { message, suggestion } = formatError(error);
+                console.log(colors.error(`Failed to install skill: ${message}`));
+                console.log(colors.textMuted(suggestion));
+                console.log('');
+                process.exit(1);
+            }
+        }
+        else {
+            // Remote installation
+            console.log(colors.textMuted(`  Source: ${source}`));
+            console.log(colors.textMuted(`  Type: Remote`));
+            console.log('');
+            try {
+                const result = await installSkill(source);
+                if (result.success) {
+                    console.log(colors.success(`✅ Skill "${result.skillName}" installed successfully`));
+                    console.log(colors.textMuted(`  Location: ${result.skillPath}`));
+                    console.log('');
+                    // Notify running xAgent to update system prompt
+                    await notifySkillUpdate(userSkillsPath);
+                    console.log(colors.textMuted('Note: Run "xagent start" to use the new skill'));
+                    console.log('');
+                }
+                else {
+                    console.log(colors.error(`Failed to install skill: ${result.error}`));
+                    console.log('');
+                    process.exit(1);
+                }
+            }
+            catch (error) {
+                const { message, suggestion } = formatError(error);
+                console.log(colors.error(`Failed to install skill: ${message}`));
+                console.log(colors.textMuted(suggestion));
+                console.log('');
+                process.exit(1);
+            }
+        }
+    }
+    else if (options.list) {
+        const separator = icons.separator.repeat(40);
+        console.log('');
+        console.log(colors.primaryBright(`${icons.tool} Skills`));
+        console.log(colors.border(separator));
+        console.log('');
+        try {
+            const entries = await fs.readdir(userSkillsPath, { withFileTypes: true });
+            const skills = entries.filter(e => e.isDirectory());
+            if (skills.length === 0) {
+                console.log(colors.textMuted('No user skills installed'));
+                console.log('');
+                return;
+            }
+            for (const skill of skills) {
+                const skillPath = path.join(userSkillsPath, skill.name);
+                const skillMdPath = path.join(skillPath, 'SKILL.md');
+                try {
+                    const content = await fs.readFile(skillMdPath, 'utf-8');
+                    // Simple parsing for name and description
+                    const nameMatch = content.match(/^name:\s*(.+)$/m);
+                    const descMatch = content.match(/^description:\s*(.+)$/m);
+                    const name = nameMatch ? nameMatch[1].trim() : skill.name;
+                    const description = descMatch ? descMatch[1].trim() : 'No description';
+                    console.log(`  ${colors.primaryBright(`• ${name}`)}`);
+                    console.log(`    ${colors.textDim(`  ${description}`)}`);
+                    console.log('');
+                }
+                catch {
+                    console.log(`  ${colors.primaryBright(`• ${skill.name}`)}`);
+                    console.log(`    ${colors.textDim(`  (Missing SKILL.md)`)}`);
+                    console.log('');
+                }
+            }
+            console.log(colors.textMuted(`Skills directory: ${userSkillsPath}`));
+            console.log('');
+        }
+        catch (error) {
+            console.log(colors.textMuted('No user skills installed'));
+            console.log('');
+        }
+    }
+    else if (options.remove) {
+        const skillPath = path.join(userSkillsPath, options.remove);
+        // Protect find-skills from deletion
+        if (options.remove === 'find-skills') {
+            console.log('');
+            console.log(colors.error(`Cannot remove protected skill: find-skills`));
+            console.log(colors.textMuted('find-skills is a built-in skill that helps you discover and install other skills.'));
+            console.log('');
+            process.exit(1);
+        }
+        try {
+            await fs.access(skillPath);
+            // Verify it's in user skills path (not built-in)
+            if (!skillPath.startsWith(userSkillsPath)) {
+                console.log('');
+                console.log(colors.error(`Cannot remove skill outside user directory: ${options.remove}`));
+                console.log('');
+                process.exit(1);
+            }
+            // Remove the skill directory
+            await fs.rm(skillPath, { recursive: true, force: true });
+            console.log('');
+            console.log(colors.success(`✅ Skill ${options.remove} removed successfully`));
+            console.log('');
+            // Notify running xAgent to update system prompt
+            await notifySkillUpdate(userSkillsPath);
+            console.log('');
+        }
+        catch (error) {
+            console.log('');
+            console.log(colors.error(`Skill not found: ${options.remove}`));
+            console.log('');
+            process.exit(1);
+        }
+    }
+    else {
+        // Show help
+        console.log('');
+        console.log(colors.textMuted('Usage:'));
+        console.log(`  ${colors.primaryBright('xagent skill -l')}                    ${colors.textDim('| List all skills')}`);
+        console.log(`  ${colors.primaryBright('xagent skill --add <source>')}        ${colors.textDim('| Install skill (auto-detects local or remote)')}`);
+        console.log(`  ${colors.primaryBright('xagent skill -r <name>')}             ${colors.textDim('| Remove a skill')}`);
+        console.log('');
+        console.log(colors.textMuted('Examples:'));
+        console.log(`  ${colors.primaryBright('xagent skill --add ./my-skill')}           ${colors.textDim('| Install from local path')}`);
+        console.log(`  ${colors.primaryBright('xagent skill --add owner/repo')}          ${colors.textDim('| Install from GitHub')}`);
+        console.log(`  ${colors.primaryBright('xagent skill --add https://github.com/owner/repo')}`);
+        console.log(`  ${colors.primaryBright('xagent skill --add https://docs.example.com/skill.md')}`);
+        console.log('');
+        console.log(colors.textMuted('To install a new skill, use the interactive command:'));
+        console.log(`  ${colors.primaryBright('/skill add')}`);
+        console.log('');
+    }
+});
 program
     .command('version')
     .description('Display version and check for updates')
@@ -433,11 +996,14 @@ program
             console.log('');
         }
         const { createGUISubAgent } = await import('./gui-subagent/index.js');
+        // Create ref for tracking first VLM call across loop iterations
+        const isFirstVlmCallRef = { current: true };
         // Create remoteVlmCaller for remote mode (uses full messages for consistent behavior)
         let remoteVlmCaller;
         if (!isLocalMode && authConfig.baseUrl) {
             const remoteBaseUrl = `${authConfig.baseUrl}/api/agent/vlm`;
-            remoteVlmCaller = async (messages, _systemPrompt) => {
+            remoteVlmCaller = async (messages, _systemPrompt, _taskId, isFirstVlmCallRef) => {
+                const status = isFirstVlmCallRef.current ? 'begin' : 'continue';
                 const response = await fetch(remoteBaseUrl, {
                     method: 'POST',
                     headers: {
@@ -445,7 +1011,9 @@ program
                         'Authorization': `Bearer ${authConfig.apiKey || ''}`,
                     },
                     body: JSON.stringify({
-                        messages
+                        messages,
+                        taskId: _taskId,
+                        status
                     }),
                 });
                 if (!response.ok) {
@@ -453,6 +1021,8 @@ program
                     throw new Error(`Remote VLM error: ${response.status} - ${errorText}`);
                 }
                 const result = await response.json();
+                // Update ref after call so subsequent calls use 'continue'
+                isFirstVlmCallRef.current = false;
                 return result.response || result.content || result.message || '';
             };
         }
@@ -461,6 +1031,7 @@ program
             model: isLocalMode ? modelName : undefined,
             modelBaseUrl: isLocalMode ? baseUrl : undefined,
             modelApiKey: isLocalMode ? apiKey : undefined,
+            isFirstVlmCallRef,
             remoteVlmCaller,
             isLocalMode,
         });
@@ -670,6 +1241,48 @@ program
         console.log('');
     }
 });
+program
+    .command('update')
+    .description('Check for updates and update xAgent CLI')
+    .action(async () => {
+    const separator = icons.separator.repeat(40);
+    console.log('');
+    console.log(colors.primaryBright(`${icons.rocket} Update Check`));
+    console.log(colors.border(separator));
+    console.log('');
+    try {
+        const { getUpdateManager } = await import('./update.js');
+        const updateManager = getUpdateManager();
+        const versionInfo = await updateManager.checkForUpdates();
+        console.log(`  ${icons.info}  ${colors.textMuted('Current version:')} ${colors.primaryBright(versionInfo.currentVersion)}`);
+        console.log(`  ${icons.code} ${colors.textMuted('Latest version:')} ${colors.primaryBright(versionInfo.latestVersion)}`);
+        console.log('');
+        if (versionInfo.updateAvailable) {
+            console.log(colors.success(`  📦 A new version is available!`));
+            console.log('');
+            if (versionInfo.releaseNotes) {
+                console.log(colors.textMuted('  Release Notes:'));
+                console.log(colors.textDim(`  ${versionInfo.releaseNotes}`));
+                console.log('');
+            }
+            const shouldUpdate = await confirm({
+                message: 'Do you want to update now?',
+            });
+            if (shouldUpdate === true) {
+                console.log('');
+                await updateManager.autoUpdate();
+            }
+        }
+        else {
+            console.log(colors.success(`  ✅ You are using the latest version`));
+            console.log('');
+        }
+    }
+    catch (error) {
+        console.log(colors.error(`  ❌ Failed to check for updates: ${error.message}`));
+        console.log('');
+    }
+});
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
     program.outputHelp();