@mcp-use/cli 1.0.0 → 1.0.1

package/dist/services/mcp-config-service.js

@@ -0,0 +1,426 @@
+import { SecureStorage } from '../storage.js';
+export class MCPConfigService {
+    constructor() {
+        Object.defineProperty(this, "persistentConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.persistentConfig = SecureStorage.loadConfig();
+    }
+    getConfiguredServers() {
+        return this.persistentConfig.mcpServers || {};
+    }
+    isServerConfigured(serverName) {
+        return !!this.persistentConfig.mcpServers?.[serverName];
+    }
+    addServerFromJSON(jsonConfig) {
+        try {
+            const parsedConfig = JSON.parse(jsonConfig);
+            // Validate JSON structure
+            if (!parsedConfig.mcpServers ||
+                typeof parsedConfig.mcpServers !== 'object') {
+                return {
+                    success: false,
+                    message: 'Invalid JSON format. Expected format:\n{\n  "mcpServers": {\n    "servername": {\n      "command": "...",\n      "args": [...]\n    }\n  }\n}',
+                };
+            }
+            const servers = parsedConfig.mcpServers;
+            const serverNames = Object.keys(servers);
+            if (serverNames.length === 0) {
+                return {
+                    success: false,
+                    message: 'No servers found in JSON configuration.',
+                };
+            }
+            // Check for conflicts with existing servers
+            const existingServers = this.persistentConfig.mcpServers || {};
+            const conflicts = serverNames.filter(name => existingServers[name]);
+            if (conflicts.length > 0) {
+                return {
+                    success: false,
+                    message: `Server(s) already exist: ${conflicts.join(', ')}. Please use different names.`,
+                };
+            }
+            // Validate each server config
+            for (const [name, serverConfig] of Object.entries(servers)) {
+                const server = serverConfig;
+                if (!server.command || typeof server.command !== 'string') {
+                    return {
+                        success: false,
+                        message: `Server "${name}" missing required "command" field.`,
+                    };
+                }
+            }
+            // All validation passed, save the servers
+            if (!this.persistentConfig.mcpServers) {
+                this.persistentConfig.mcpServers = {};
+            }
+            // Add all servers from JSON
+            Object.assign(this.persistentConfig.mcpServers, servers);
+            SecureStorage.saveConfig(this.persistentConfig);
+            const serverList = serverNames.map(name => `• ${name}`).join('\n');
+            return {
+                success: true,
+                message: `Configured ${serverNames.length} server(s)!\n\n${serverList}`,
+                data: {
+                    serversAdded: true,
+                    serverNames,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Invalid JSON format: ${error instanceof Error ? error.message : 'Parse error'}\n\nPlease check your JSON syntax and try again.`,
+            };
+        }
+    }
+    addServer(name, config) {
+        // Check if server name already exists
+        if (this.persistentConfig.mcpServers?.[name]) {
+            return {
+                success: false,
+                message: `Server "${name}" already exists. Use a different name.`,
+            };
+        }
+        // Add server to persistent configuration
+        if (!this.persistentConfig.mcpServers) {
+            this.persistentConfig.mcpServers = {};
+        }
+        this.persistentConfig.mcpServers[name] = config;
+        // Save configuration
+        SecureStorage.saveConfig(this.persistentConfig);
+        return {
+            success: true,
+            message: `Server "${name}" configured!`,
+            data: {
+                serverAdded: true,
+                serverName: name,
+            },
+        };
+    }
+    /**
+     * Gets the configuration for a specific server.
+     * @param serverName - Name of the server
+     * @returns The server configuration or null if not found
+     */
+    getServerConfig(serverName) {
+        return this.persistentConfig.mcpServers?.[serverName] || null;
+    }
+    /**
+     * Gets all configured servers with their configurations.
+     * Note: Connection status should be determined by the caller using AgentService.
+     * @returns Array of server configurations
+     */
+    getAllServers() {
+        const persistentServers = this.persistentConfig.mcpServers || {};
+        const servers = [];
+        for (const [name, config] of Object.entries(persistentServers)) {
+            servers.push({
+                name,
+                config,
+            });
+        }
+        return servers;
+    }
+    getServerTestCommand(serverName) {
+        const serverConfig = this.persistentConfig.mcpServers?.[serverName];
+        if (!serverConfig) {
+            const configuredServers = Object.keys(this.persistentConfig.mcpServers || {});
+            return {
+                success: false,
+                message: `Server "${serverName}" is not configured.\n\nConfigured servers: ${configuredServers.length > 0 ? configuredServers.join(', ') : 'none'}`,
+            };
+        }
+        const command = serverConfig.command;
+        const args_str = serverConfig.args ? serverConfig.args.join(' ') : '';
+        const full_command = `${command} ${args_str}`.trim();
+        return {
+            success: true,
+            command: full_command,
+        };
+    }
+    validateServerName(name) {
+        if (!name || !name.trim()) {
+            return { valid: false, message: 'Server name cannot be empty.' };
+        }
+        if (this.persistentConfig.mcpServers?.[name.trim()]) {
+            return {
+                valid: false,
+                message: `Server "${name.trim()}" already exists. Use a different name.`,
+            };
+        }
+        return { valid: true };
+    }
+    parseEnvironmentVariables(envString) {
+        const env = {};
+        if (envString.trim()) {
+            const envLines = envString.trim().split('\n');
+            for (const line of envLines) {
+                const [key, ...valueParts] = line.split('=');
+                if (key && valueParts.length > 0) {
+                    env[key.trim()] = valueParts.join('=').trim();
+                }
+            }
+        }
+        return env;
+    }
+    /**
+     * Handles the /server command and its subcommands.
+     * @param args - Array of arguments where args[0] is the subcommand
+     * @returns A CommandResult with the appropriate response
+     */
+    handleServerCommand(args) {
+        if (args.length === 0) {
+            return {
+                type: 'info',
+                message: 'Server management commands:\n\n/server add              - Configure a new server (stored but not connected)\n/server connect <name>   - Connect to a configured server by name\n/server disconnect <name> - Disconnect from a connected server\n/servers                 - List configured servers and connection status\n\nUse /server <command> for specific help.',
+            };
+        }
+        if (args[0] === 'add') {
+            return {
+                type: 'prompt_server_config',
+                message: 'Let\'s configure a new MCP server!\n\nYou can either:\n1. Enter a server name for interactive setup\n2. Paste a complete JSON configuration\n\nExample JSON:\n{\n  "mcpServers": {\n    "myserver": {\n      "command": "npx",\n      "args": ["-y", "@example/server"]\n    }\n  }\n}\n\nEnter server name or paste JSON:',
+                data: { step: 'name_or_json' },
+            };
+        }
+        if (args[0] === 'connect') {
+            if (args.length < 2) {
+                const configuredServers = Object.keys(this.getConfiguredServers());
+                if (configuredServers.length === 0) {
+                    return {
+                        type: 'error',
+                        message: 'No servers configured. Use /server add to configure servers first.\n\nUsage: /server connect <server_name>',
+                    };
+                }
+                return {
+                    type: 'error',
+                    message: `Usage: /server connect <server_name>\n\nConfigured servers: ${configuredServers.join(', ')}`,
+                };
+            }
+            const serverName = args[1];
+            if (!serverName) {
+                return {
+                    type: 'error',
+                    message: 'Server name is required.\n\nUsage: /server connect <server_name>',
+                };
+            }
+            return {
+                type: 'info',
+                message: `Server connect command received for: ${serverName}`,
+                data: { connectServer: true, serverName },
+            };
+        }
+        if (args[0] === 'disconnect') {
+            if (args.length < 2) {
+                return {
+                    type: 'error',
+                    message: 'Usage: /server disconnect <server_name>',
+                };
+            }
+            const serverName = args[1];
+            if (!serverName) {
+                return {
+                    type: 'error',
+                    message: 'Server name is required.\n\nUsage: /server disconnect <server_name>',
+                };
+            }
+            return {
+                type: 'info',
+                message: `Server disconnect command received for: ${serverName}`,
+                data: { disconnectServer: true, serverName },
+            };
+        }
+        return {
+            type: 'error',
+            message: 'Usage: /server <command>\n\nCommands:\n  add              - Configure server\n  connect <name>   - Connect to server\n  disconnect <name> - Disconnect server\n\nExample: /server connect airbnb',
+        };
+    }
+    /**
+     * Handles the /servers command to list all servers and their connection status.
+     * @returns A CommandResult with the server list
+     */
+    handleListServersCommand() {
+        const servers = this.getAllServers();
+        if (servers.length === 0) {
+            return {
+                type: 'info',
+                message: 'No custom servers configured.\n\nUse /server add to configure servers, then /server connect <name> to connect.',
+            };
+        }
+        return {
+            type: 'list_servers',
+            message: 'MCP Server Status:',
+            data: { servers },
+        };
+    }
+    /**
+     * Handles the /test-server command to test server configuration.
+     * @param args - Array where args[0] is the server name
+     * @returns A CommandResult with test information
+     */
+    handleTestServerCommand(args) {
+        if (args.length === 0) {
+            const configuredServers = Object.keys(this.getConfiguredServers());
+            if (configuredServers.length === 0) {
+                return {
+                    type: 'error',
+                    message: 'No servers configured to test.\n\nUsage: /test-server <server_name>\n\nUse /server add to configure servers first.',
+                };
+            }
+            return {
+                type: 'info',
+                message: `Usage: /test-server <server_name>\n\nConfigured servers: ${configuredServers.join(', ')}\n\nThis command will test if the server package can be started manually.`,
+            };
+        }
+        const serverName = args[0];
+        if (!serverName) {
+            return {
+                type: 'error',
+                message: 'Server name is required.\n\nUsage: /test-server <server_name>',
+            };
+        }
+        const result = this.getServerTestCommand(serverName);
+        if (!result.success) {
+            return {
+                type: 'error',
+                message: result.message,
+            };
+        }
+        return {
+            type: 'info',
+            message: `🧪 Testing server "${serverName}"...\n\nCommand: ${result.command}\n\n⚠️ Note: This will attempt to run the server command manually.\nCheck the console for output and errors.\n\n💡 Try running this command manually in your terminal:\n${result.command}`,
+            data: { testServer: true, serverName, command: result.command },
+        };
+    }
+    /**
+     * Handles server configuration input during the interactive setup flow.
+     * @param input - User input string
+     * @param step - Current step in the configuration flow
+     * @param serverConfig - Partial server configuration being built
+     * @returns A CommandResult to continue or complete the flow
+     */
+    handleServerConfigInput(input, step, serverConfig) {
+        const config = serverConfig || {};
+        switch (step) {
+            case 'name_or_json':
+                // Check if input looks like JSON
+                const trimmedInput = input.trim();
+                if (trimmedInput.startsWith('{') &&
+                    trimmedInput.includes('mcpServers')) {
+                    const result = this.addServerFromJSON(trimmedInput);
+                    if (!result.success) {
+                        return {
+                            type: 'error',
+                            message: result.message,
+                        };
+                    }
+                    return {
+                        type: 'success',
+                        message: `${result.message}.`,
+                        data: result.data,
+                    };
+                }
+                // Not JSON, treat as server name for interactive setup
+                const validation = this.validateServerName(trimmedInput);
+                if (!validation.valid) {
+                    return {
+                        type: 'error',
+                        message: validation.message,
+                    };
+                }
+                config.name = trimmedInput;
+                return {
+                    type: 'prompt_server_config',
+                    message: `Server name: ${config.name}\n\nEnter the command to run this server (e.g., "npx", "node", "python"):`,
+                    data: { step: 'command', config },
+                };
+            case 'name':
+                const nameValidation = this.validateServerName(input.trim());
+                if (!nameValidation.valid) {
+                    return {
+                        type: 'error',
+                        message: nameValidation.message,
+                    };
+                }
+                config.name = input.trim();
+                return {
+                    type: 'prompt_server_config',
+                    message: `Server name: ${config.name}\n\nEnter the command to run this server (e.g., "npx", "node", "python"):`,
+                    data: { step: 'command', config },
+                };
+            case 'command':
+                if (!input.trim()) {
+                    return {
+                        type: 'error',
+                        message: 'Command cannot be empty.',
+                    };
+                }
+                config.command = input.trim();
+                return {
+                    type: 'prompt_server_config',
+                    message: `Server name: ${config.name}\nCommand: ${config.command}\n\nEnter arguments (space-separated, or press Enter for none):\nExample: "-y @modelcontextprotocol/server-filesystem /tmp"`,
+                    data: { step: 'args', config },
+                };
+            case 'args':
+                config.args = input.trim() ? input.trim().split(/\s+/) : [];
+                return {
+                    type: 'prompt_server_config',
+                    message: `Server name: ${config.name}\nCommand: ${config.command}\nArgs: ${config.args.length > 0 ? config.args.join(' ') : 'none'}\n\nEnter environment variables (KEY=VALUE format, one per line, or press Enter for none):\nExample: "DEBUG=1" or press Enter to skip:`,
+                    data: { step: 'env', config },
+                };
+            case 'env':
+                config.env = this.parseEnvironmentVariables(input);
+                return {
+                    type: 'prompt_server_config',
+                    message: `Server Configuration Summary:\n\nName: ${config.name}\nCommand: ${config.command}\nArgs: ${config.args.length > 0 ? config.args.join(' ') : 'none'}\nEnv: ${Object.keys(config.env).length > 0
+                        ? Object.entries(config.env)
+                            .map(([k, v]) => `${k}=${v}`)
+                            .join(', ')
+                        : 'none'}\n\nConfirm to add this server? (y/n):`,
+                    data: { step: 'confirm', config },
+                };
+            case 'confirm':
+                if (input.trim().toLowerCase() === 'y' ||
+                    input.trim().toLowerCase() === 'yes') {
+                    const serverConfig = {
+                        command: config.command,
+                        args: config.args,
+                        env: config.env,
+                    };
+                    const result = this.addServer(config.name, serverConfig);
+                    if (!result.success) {
+                        return {
+                            type: 'error',
+                            message: result.message,
+                        };
+                    }
+                    return {
+                        type: 'success',
+                        message: `${result.message}.`,
+                        data: result.data,
+                    };
+                }
+                else if (input.trim().toLowerCase() === 'n' ||
+                    input.trim().toLowerCase() === 'no') {
+                    return {
+                        type: 'info',
+                        message: 'Server configuration cancelled.',
+                    };
+                }
+                else {
+                    return {
+                        type: 'error',
+                        message: 'Please enter "y" for yes or "n" for no.',
+                    };
+                }
+            default:
+                return {
+                    type: 'error',
+                    message: 'Invalid server configuration step.',
+                };
+        }
+    }
+}

package/dist/services/mcp-service.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/mcp-service.js

@@ -0,0 +1 @@
+export {};

package/dist/services/utility-service.d.ts

@@ -0,0 +1,47 @@
+import type { CommandResult } from '../types.js';
+import type { LLMService } from './llm-service.js';
+import type { MCPConfigService } from './mcp-config-service.js';
+/**
+ * Service that handles utility commands like help, logs, history, and status.
+ * These commands provide information and debugging capabilities but don't
+ * modify the core application state.
+ */
+export declare class UtilityService {
+    private llmService;
+    /**
+     * Creates a new UtilityService instance.
+     * @param deps - Dependencies required by the service
+     * @param deps.llmService - Service for LLM operations (used for status)
+     * @param deps.mcpConfigService - Service for MCP config (used for status)
+     */
+    constructor(deps: {
+        llmService: LLMService;
+        mcpConfigService: MCPConfigService;
+    });
+    /**
+     * Handles the /help command to show available commands.
+     * @returns A CommandResult with the help text
+     */
+    handleHelpCommand(): CommandResult;
+    /**
+     * Handles the /status command to show current configuration.
+     * @returns A CommandResult with the current status
+     */
+    handleStatusCommand(): CommandResult;
+    /**
+     * Handles the /logs command and its subcommands.
+     * @param args - Array of arguments where args[0] is the subcommand
+     * @returns A CommandResult with log information
+     */
+    handleLogsCommand(args: string[]): CommandResult;
+    /**
+     * Handles the /clearlogs command to clear debug logs.
+     * @returns A CommandResult indicating success or failure
+     */
+    handleClearLogsCommand(): CommandResult;
+    /**
+     * Handles the /history command to show input history navigation info.
+     * @returns A CommandResult with history navigation instructions
+     */
+    handleHistoryCommand(): CommandResult;
+}

package/dist/services/utility-service.js

@@ -0,0 +1,208 @@
+import { Logger } from '../logger.js';
+/**
+ * Service that handles utility commands like help, logs, history, and status.
+ * These commands provide information and debugging capabilities but don't
+ * modify the core application state.
+ */
+export class UtilityService {
+    /**
+     * Creates a new UtilityService instance.
+     * @param deps - Dependencies required by the service
+     * @param deps.llmService - Service for LLM operations (used for status)
+     * @param deps.mcpConfigService - Service for MCP config (used for status)
+     */
+    constructor(deps) {
+        Object.defineProperty(this, "llmService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.llmService = deps.llmService;
+        // mcpConfigService is passed but not used currently
+        // Kept in constructor signature for potential future use and API consistency
+    }
+    /**
+     * Handles the /help command to show available commands.
+     * @returns A CommandResult with the help text
+     */
+    handleHelpCommand() {
+        const helpText = `
+Available slash commands:
+
+🤖 Get Started:
+  /model <provider> <model>  - Choose your LLM (CLI handles API key setup)
+  /models [provider]         - List available models for a provider
+
+🔌 MCP Servers:
+  /server add                - Configure a new server (auto-connects)
+  /server connect <name>     - Connect to a configured server by name  
+  /server disconnect <name>  - Disconnect from a connected server
+  /servers                   - List servers and their connection status
+  /tools                     - Show available tools from connected servers
+  /test-server <name>        - Test if a server package can be started
+
+🔑 API Keys (automatic):
+  /setkey <provider> <key>   - Set API key manually (stored securely)
+  /clearkeys                 - Clear all stored API keys
+
+⚙️  Configuration:
+  /config temp <value>       - Set temperature (0.0-2.0)
+  /config tokens <value>     - Set max tokens
+  /help                      - Show this help
+
+🛠️  Debugging & History:
+  /logs [path|tail]          - View debug logs (written to ~/.mcp-use-cli/debug.log)
+  /clearlogs                 - Clear debug logs
+  /history                   - Info about input history navigation (↑↓ arrows)
+
+📋 Quick Start Examples:
+  /model openai gpt-4o-mini
+  /server add                # Interactive server setup
+  /servers
+  /config temp 0.5
+		`.trim();
+        return {
+            type: 'info',
+            message: helpText,
+        };
+    }
+    /**
+     * Handles the /status command to show current configuration.
+     * @returns A CommandResult with the current status
+     */
+    handleStatusCommand() {
+        const availableProviders = this.llmService.getAvailableProviders();
+        const currentConfig = this.llmService.getCurrentConfig();
+        const apiKeyStatus = this.llmService.getApiKeyStatus();
+        let statusText = '🤖 Current Configuration:\n\n';
+        // API Keys status
+        statusText += '🔑 API Keys:\n';
+        Object.entries(apiKeyStatus).forEach(([provider, status]) => {
+            if (status.status === 'set') {
+                statusText += `  • ${provider}: ${status.masked} (${status.source})\n`;
+            }
+            else {
+                statusText += `  • ${provider}: ❌ not set\n`;
+            }
+        });
+        statusText += '\n';
+        // Current model
+        if (!currentConfig) {
+            if (availableProviders.length === 0) {
+                statusText += '⚠️ No model selected\n';
+                statusText += '\nChoose a model to get started:\n';
+                statusText += '• /model openai gpt-4o-mini\n';
+                statusText += '• /model anthropic claude-3-5-sonnet-20241022\n';
+                statusText += '• /model google gemini-1.5-pro\n';
+                statusText += '\nThe CLI will help you set up API keys when needed.';
+            }
+            else {
+                statusText += '⚠️ No model selected\n';
+                statusText += `\nAvailable providers: ${availableProviders.join(', ')}\n`;
+                statusText += 'Use /model <provider> <model> to get started';
+            }
+        }
+        else {
+            statusText += `🎯 Active Model:\n`;
+            statusText += `  Provider: ${currentConfig.provider}\n`;
+            statusText += `  Model: ${currentConfig.model}\n`;
+            statusText += `  Temperature: ${currentConfig.temperature || 0.7}\n`;
+            statusText += `  Max Tokens: ${currentConfig.maxTokens || 'default'}\n`;
+            statusText +=
+                '\nUse /model to switch models or /config to adjust settings';
+        }
+        return {
+            type: 'info',
+            message: statusText,
+        };
+    }
+    /**
+     * Handles the /logs command and its subcommands.
+     * @param args - Array of arguments where args[0] is the subcommand
+     * @returns A CommandResult with log information
+     */
+    handleLogsCommand(args) {
+        const logPath = Logger.getLogPath();
+        if (args.length === 0) {
+            return {
+                type: 'info',
+                message: `📋 Debug logs are written to:\n${logPath}\n\nCommands:\n  /logs path    - Show log file path\n  /logs tail    - Show recent log entries\n  /clearlogs    - Clear all logs\n\nTo view logs in real-time:\n  tail -f ${logPath}`,
+            };
+        }
+        const subcommand = args[0];
+        switch (subcommand) {
+            case 'path':
+                return {
+                    type: 'info',
+                    message: `📁 Log file location:\n${logPath}`,
+                };
+            case 'tail':
+                try {
+                    const fs = require('fs');
+                    if (!fs.existsSync(logPath)) {
+                        return {
+                            type: 'info',
+                            message: '📋 No log file found yet. Logs will be created when the app starts logging.',
+                        };
+                    }
+                    const logContent = fs.readFileSync(logPath, 'utf8');
+                    const lines = logContent
+                        .split('\n')
+                        .filter((line) => line.trim());
+                    const recentLines = lines.slice(-20); // Show last 20 lines
+                    if (recentLines.length === 0) {
+                        return {
+                            type: 'info',
+                            message: '📋 Log file is empty.',
+                        };
+                    }
+                    return {
+                        type: 'info',
+                        message: `📋 Recent log entries (last ${recentLines.length} lines):\n\n${recentLines.join('\n')}`,
+                    };
+                }
+                catch (error) {
+                    return {
+                        type: 'error',
+                        message: `❌ Failed to read logs: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    };
+                }
+            default:
+                return {
+                    type: 'error',
+                    message: `Unknown logs subcommand: ${subcommand}. Use /logs for help.`,
+                };
+        }
+    }
+    /**
+     * Handles the /clearlogs command to clear debug logs.
+     * @returns A CommandResult indicating success or failure
+     */
+    handleClearLogsCommand() {
+        try {
+            Logger.clearLogs();
+            Logger.info('Logs cleared by user command');
+            return {
+                type: 'success',
+                message: '✅ Debug logs cleared successfully.',
+            };
+        }
+        catch (error) {
+            return {
+                type: 'error',
+                message: `❌ Failed to clear logs: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Handles the /history command to show input history navigation info.
+     * @returns A CommandResult with history navigation instructions
+     */
+    handleHistoryCommand() {
+        return {
+            type: 'info',
+            message: `📜 Input History Navigation:\n\n🔼 Arrow Up   - Navigate to previous inputs\n🔽 Arrow Down - Navigate to newer inputs\n\n💡 Tips:\n• Your input history is automatically saved during the session\n• Use ↑ to recall previous commands and messages\n• Use ↓ to navigate back to newer inputs\n• History is reset when you restart the CLI\n\n🎯 Try it now: Press the up arrow key in the input box!`,
+        };
+    }
+}