@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/commands/mcp.ts

@@ -1,753 +0,0 @@
-/**
- * V3 CLI MCP Command
- * MCP server control and management with real server integration
- *
- * @module @claude-flow/cli/commands/mcp
- * @version 3.0.0
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-import { select, confirm } from '../prompt.js';
-import {
-  MCPServerManager,
-  createMCPServerManager,
-  getServerManager,
-  startMCPServer,
-  stopMCPServer,
-  getMCPServerStatus,
-  type MCPServerOptions,
-  type MCPServerStatus,
-} from '../mcp-server.js';
-import { listMCPTools, callMCPTool, hasTool, getToolMetadata } from '../mcp-client.js';
-
-// MCP tools categories
-const TOOL_CATEGORIES = [
-  { value: 'coordination', label: 'Coordination', hint: 'Swarm and agent coordination tools' },
-  { value: 'monitoring', label: 'Monitoring', hint: 'Status and metrics monitoring' },
-  { value: 'memory', label: 'Memory', hint: 'Memory and neural features' },
-  { value: 'github', label: 'GitHub', hint: 'GitHub integration tools' },
-  { value: 'system', label: 'System', hint: 'System and benchmark tools' }
-];
-
-/**
- * Format uptime for display
- */
-function formatUptime(seconds: number): string {
-  if (seconds < 60) {
-    return `${seconds}s`;
-  }
-  if (seconds < 3600) {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}m ${secs}s`;
-  }
-  const hours = Math.floor(seconds / 3600);
-  const mins = Math.floor((seconds % 3600) / 60);
-  return `${hours}h ${mins}m`;
-}
-
-// Start MCP server
-const startCommand: Command = {
-  name: 'start',
-  description: 'Start MCP server',
-  options: [
-    {
-      name: 'port',
-      short: 'p',
-      description: 'Server port',
-      type: 'number',
-      default: 3000
-    },
-    {
-      name: 'host',
-      short: 'h',
-      description: 'Server host',
-      type: 'string',
-      default: 'localhost'
-    },
-    {
-      name: 'transport',
-      short: 't',
-      description: 'Transport type (stdio, http, websocket)',
-      type: 'string',
-      default: 'stdio',
-      choices: ['stdio', 'http', 'websocket']
-    },
-    {
-      name: 'tools',
-      description: 'Tools to enable (comma-separated or "all")',
-      type: 'string',
-      default: 'all'
-    },
-    {
-      name: 'daemon',
-      short: 'd',
-      description: 'Run as background daemon',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  examples: [
-    { command: 'claude-flow mcp start', description: 'Start with defaults (stdio)' },
-    { command: 'claude-flow mcp start -p 8080 -t http', description: 'Start HTTP server' },
-    { command: 'claude-flow mcp start -d', description: 'Start as daemon' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const port = ctx.flags.port as number;
-    const host = ctx.flags.host as string;
-    const transport = ctx.flags.transport as 'stdio' | 'http' | 'websocket';
-    const tools = ctx.flags.tools as string;
-    const daemon = ctx.flags.daemon as boolean;
-
-    output.writeln();
-    output.printInfo('Starting MCP Server...');
-    output.writeln();
-
-    // Check if already running
-    const existingStatus = await getMCPServerStatus();
-    if (existingStatus.running) {
-      output.printWarning(`MCP Server already running (PID: ${existingStatus.pid})`);
-      output.writeln(output.dim('Use "claude-flow mcp stop" to stop the server first'));
-      return { success: false, exitCode: 1 };
-    }
-
-    const options: MCPServerOptions = {
-      transport,
-      host,
-      port,
-      tools: tools === 'all' ? 'all' : tools.split(','),
-      daemonize: daemon,
-    };
-
-    try {
-      output.writeln(output.dim('  Initializing server...'));
-
-      const manager = getServerManager(options);
-
-      // Setup event handlers for progress display
-      manager.on('starting', () => {
-        output.writeln(output.dim('  Loading tool registry...'));
-      });
-
-      manager.on('started', (data: any) => {
-        output.writeln(output.dim(`  Server started in ${data.startupTime?.toFixed(2) || 0}ms`));
-      });
-
-      manager.on('log', (log: { level: string; msg: string; data?: unknown }) => {
-        if (ctx.flags.verbose) {
-          output.writeln(output.dim(`  [${log.level}] ${log.msg}`));
-        }
-      });
-
-      // Start the server
-      const status = await manager.start();
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'property', header: 'Property', width: 15 },
-          { key: 'value', header: 'Value', width: 30 }
-        ],
-        data: [
-          { property: 'Server PID', value: status.pid || process.pid },
-          { property: 'Transport', value: transport },
-          { property: 'Host', value: host },
-          { property: 'Port', value: port },
-          { property: 'Tools', value: tools === 'all' ? '27 enabled' : `${tools.split(',').length} enabled` },
-          { property: 'Status', value: output.success('Running') }
-        ]
-      });
-
-      output.writeln();
-      output.printSuccess('MCP Server started');
-
-      if (transport === 'http') {
-        output.writeln(output.dim(`  Health: http://${host}:${port}/health`));
-        output.writeln(output.dim(`  RPC: http://${host}:${port}/rpc`));
-      } else if (transport === 'websocket') {
-        output.writeln(output.dim(`  WebSocket: ws://${host}:${port}/ws`));
-      }
-
-      if (daemon) {
-        output.writeln(output.dim('  Running in background mode'));
-      }
-
-      return { success: true, data: status };
-    } catch (error) {
-      output.printError(`Failed to start MCP server: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Stop MCP server
-const stopCommand: Command = {
-  name: 'stop',
-  description: 'Stop MCP server',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force stop without graceful shutdown',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const force = ctx.flags.force as boolean;
-
-    // Check if server is running
-    const status = await getMCPServerStatus();
-    if (!status.running) {
-      output.printInfo('MCP Server is not running');
-      return { success: true };
-    }
-
-    if (!force && ctx.interactive) {
-      const confirmed = await confirm({
-        message: `Stop MCP server (PID: ${status.pid})?`,
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    output.printInfo('Stopping MCP Server...');
-
-    try {
-      const manager = getServerManager();
-
-      if (!force) {
-        output.writeln(output.dim('  Completing pending requests...'));
-        output.writeln(output.dim('  Closing connections...'));
-      }
-
-      await manager.stop(force);
-
-      output.writeln(output.dim('  Releasing resources...'));
-      output.printSuccess('MCP Server stopped');
-
-      return { success: true, data: { stopped: true, force } };
-    } catch (error) {
-      output.printError(`Failed to stop MCP server: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// MCP status
-const statusCommand: Command = {
-  name: 'status',
-  description: 'Show MCP server status',
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    try {
-      const status = await getMCPServerStatus();
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(status);
-        return { success: true, data: status };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('MCP Server Status'));
-      output.writeln();
-
-      if (!status.running) {
-        output.printTable({
-          columns: [
-            { key: 'metric', header: 'Metric', width: 20 },
-            { key: 'value', header: 'Value', width: 20, align: 'right' }
-          ],
-          data: [
-            { metric: 'Status', value: output.error('Stopped') }
-          ]
-        });
-
-        output.writeln();
-        output.writeln(output.dim('Run "claude-flow mcp start" to start the server'));
-        return { success: true, data: status };
-      }
-
-      const displayData = [
-        { metric: 'Status', value: output.success('Running') },
-        { metric: 'PID', value: status.pid },
-        { metric: 'Transport', value: status.transport },
-        { metric: 'Host', value: status.host },
-        { metric: 'Port', value: status.port },
-      ];
-
-      if (status.uptime !== undefined) {
-        displayData.push({ metric: 'Uptime', value: formatUptime(status.uptime) });
-      }
-
-      if (status.startedAt) {
-        displayData.push({ metric: 'Started At', value: status.startedAt });
-      }
-
-      if (status.health) {
-        displayData.push({
-          metric: 'Health',
-          value: status.health.healthy
-            ? output.success('Healthy')
-            : output.error(status.health.error || 'Unhealthy')
-        });
-
-        if (status.health.metrics) {
-          for (const [key, value] of Object.entries(status.health.metrics)) {
-            displayData.push({
-              metric: `  ${key}`,
-              value: String(value)
-            });
-          }
-        }
-      }
-
-      output.printTable({
-        columns: [
-          { key: 'metric', header: 'Metric', width: 20 },
-          { key: 'value', header: 'Value', width: 25, align: 'right' }
-        ],
-        data: displayData
-      });
-
-      return { success: true, data: status };
-    } catch (error) {
-      output.printError(`Failed to get status: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// List tools
-const toolsCommand: Command = {
-  name: 'tools',
-  description: 'List available MCP tools',
-  options: [
-    {
-      name: 'category',
-      short: 'c',
-      description: 'Filter by category',
-      type: 'string',
-      choices: TOOL_CATEGORIES.map(c => c.value)
-    },
-    {
-      name: 'enabled',
-      description: 'Show only enabled tools',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const category = ctx.flags.category as string;
-
-    // Use local tool registry
-    let tools: Array<{ name: string; category: string; description: string; enabled: boolean }>;
-
-    // Get tools from local registry
-    const registeredTools = listMCPTools(category);
-
-    if (registeredTools.length > 0) {
-      tools = registeredTools.map(tool => ({
-        name: tool.name,
-        category: tool.category || 'uncategorized',
-        description: tool.description,
-        enabled: true
-      }));
-    } else {
-      // Fallback to static tool list
-      tools = [
-        // Agent tools
-        { name: 'agent/spawn', category: 'agent', description: 'Spawn a new agent', enabled: true },
-        { name: 'agent/list', category: 'agent', description: 'List all agents', enabled: true },
-        { name: 'agent/terminate', category: 'agent', description: 'Terminate an agent', enabled: true },
-        { name: 'agent/status', category: 'agent', description: 'Get agent status', enabled: true },
-
-        // Swarm tools
-        { name: 'swarm/init', category: 'swarm', description: 'Initialize swarm topology', enabled: true },
-        { name: 'swarm/status', category: 'swarm', description: 'Get swarm status', enabled: true },
-        { name: 'swarm/scale', category: 'swarm', description: 'Scale swarm size', enabled: true },
-
-        // Memory tools
-        { name: 'memory/store', category: 'memory', description: 'Store in memory', enabled: true },
-        { name: 'memory/search', category: 'memory', description: 'Search memory', enabled: true },
-        { name: 'memory/list', category: 'memory', description: 'List memory entries', enabled: true },
-
-        // Config tools
-        { name: 'config/load', category: 'config', description: 'Load configuration', enabled: true },
-        { name: 'config/save', category: 'config', description: 'Save configuration', enabled: true },
-        { name: 'config/validate', category: 'config', description: 'Validate configuration', enabled: true },
-
-        // Hooks tools
-        { name: 'hooks/pre-edit', category: 'hooks', description: 'Pre-edit hook', enabled: true },
-        { name: 'hooks/post-edit', category: 'hooks', description: 'Post-edit hook', enabled: true },
-        { name: 'hooks/pre-command', category: 'hooks', description: 'Pre-command hook', enabled: true },
-        { name: 'hooks/post-command', category: 'hooks', description: 'Post-command hook', enabled: true },
-        { name: 'hooks/route', category: 'hooks', description: 'Route task to agent', enabled: true },
-        { name: 'hooks/explain', category: 'hooks', description: 'Explain routing', enabled: true },
-        { name: 'hooks/pretrain', category: 'hooks', description: 'Pretrain from repo', enabled: true },
-        { name: 'hooks/metrics', category: 'hooks', description: 'Learning metrics', enabled: true },
-        { name: 'hooks/list', category: 'hooks', description: 'List hooks', enabled: true },
-
-        // System tools
-        { name: 'system/info', category: 'system', description: 'System information', enabled: true },
-        { name: 'system/health', category: 'system', description: 'Health status', enabled: true },
-        { name: 'system/metrics', category: 'system', description: 'Server metrics', enabled: true },
-      ].filter(t => !category || t.category === category);
-    }
-
-    if (ctx.flags.format === 'json') {
-      output.printJson(tools);
-      return { success: true, data: tools };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Available MCP Tools'));
-    output.writeln();
-
-    // Group by category
-    const grouped = tools.reduce((acc, tool) => {
-      if (!acc[tool.category]) acc[tool.category] = [];
-      acc[tool.category].push(tool);
-      return acc;
-    }, {} as Record<string, typeof tools>);
-
-    for (const [cat, catTools] of Object.entries(grouped)) {
-      output.writeln(output.highlight(cat.charAt(0).toUpperCase() + cat.slice(1)));
-
-      output.printTable({
-        columns: [
-          { key: 'name', header: 'Tool', width: 25 },
-          { key: 'description', header: 'Description', width: 35 },
-          { key: 'enabled', header: 'Status', width: 10, format: (v: unknown) => (v as boolean) ? output.success('Enabled') : output.dim('Disabled') }
-        ],
-        data: catTools,
-        border: false
-      });
-
-      output.writeln();
-    }
-
-    output.printInfo(`Total: ${tools.length} tools`);
-
-    return { success: true, data: tools };
-  }
-};
-
-// Enable/disable tools
-const toggleCommand: Command = {
-  name: 'toggle',
-  description: 'Enable or disable MCP tools',
-  options: [
-    {
-      name: 'enable',
-      short: 'e',
-      description: 'Enable tools',
-      type: 'string'
-    },
-    {
-      name: 'disable',
-      short: 'd',
-      description: 'Disable tools',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const toEnable = ctx.flags.enable as string;
-    const toDisable = ctx.flags.disable as string;
-
-    if (toEnable) {
-      const tools = toEnable.split(',');
-      output.printInfo(`Enabling tools: ${tools.join(', ')}`);
-      output.printSuccess(`Enabled ${tools.length} tools`);
-    }
-
-    if (toDisable) {
-      const tools = toDisable.split(',');
-      output.printInfo(`Disabling tools: ${tools.join(', ')}`);
-      output.printSuccess(`Disabled ${tools.length} tools`);
-    }
-
-    if (!toEnable && !toDisable) {
-      output.printError('Use --enable or --disable with comma-separated tool names');
-      return { success: false, exitCode: 1 };
-    }
-
-    return { success: true };
-  }
-};
-
-// Execute tool
-const execCommand: Command = {
-  name: 'exec',
-  description: 'Execute an MCP tool',
-  options: [
-    {
-      name: 'tool',
-      short: 't',
-      description: 'Tool name',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'params',
-      short: 'p',
-      description: 'Tool parameters (JSON)',
-      type: 'string'
-    }
-  ],
-  examples: [
-    { command: 'claude-flow mcp exec -t swarm/init -p \'{"topology":"mesh"}\'', description: 'Execute tool' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const tool = ctx.flags.tool as string || ctx.args[0];
-    const paramsStr = ctx.flags.params as string;
-
-    if (!tool) {
-      output.printError('Tool name is required. Use --tool or -t');
-      return { success: false, exitCode: 1 };
-    }
-
-    let params = {};
-    if (paramsStr) {
-      try {
-        params = JSON.parse(paramsStr);
-      } catch (e) {
-        output.printError('Invalid JSON parameters');
-        return { success: false, exitCode: 1 };
-      }
-    }
-
-    output.printInfo(`Executing tool: ${tool}`);
-
-    if (Object.keys(params).length > 0) {
-      output.writeln(output.dim(`  Parameters: ${JSON.stringify(params)}`));
-    }
-
-    try {
-      // Execute through local MCP tool registry
-      if (!hasTool(tool)) {
-        output.printError(`Tool not found: ${tool}`);
-        return { success: false, exitCode: 1 };
-      }
-
-      const startTime = performance.now();
-      const result = await callMCPTool(tool, params, {
-        sessionId: `cli-${Date.now().toString(36)}`,
-        requestId: `exec-${Date.now()}`,
-      });
-      const duration = performance.now() - startTime;
-
-      output.writeln();
-      output.printSuccess(`Tool executed in ${duration.toFixed(2)}ms`);
-
-      if (ctx.flags.format === 'json') {
-        output.printJson({ tool, params, result, duration });
-      } else {
-        output.writeln();
-        output.writeln(output.bold('Result:'));
-        output.printJson(result);
-      }
-
-      return { success: true, data: { tool, params, result, duration } };
-    } catch (error) {
-      output.printError(`Tool execution failed: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Health check command
-const healthCommand: Command = {
-  name: 'health',
-  description: 'Check MCP server health',
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    try {
-      const status = await getMCPServerStatus();
-
-      if (!status.running) {
-        output.printError('MCP Server is not running');
-        return { success: false, exitCode: 1 };
-      }
-
-      const manager = getServerManager();
-      const health = await manager.checkHealth();
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(health);
-        return { success: true, data: health };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('MCP Server Health'));
-      output.writeln();
-
-      if (health.healthy) {
-        output.printSuccess('Server is healthy');
-      } else {
-        output.printError(`Server is unhealthy: ${health.error || 'Unknown error'}`);
-      }
-
-      if (health.metrics) {
-        output.writeln();
-        output.writeln(output.bold('Metrics:'));
-        for (const [key, value] of Object.entries(health.metrics)) {
-          output.writeln(`  ${key}: ${value}`);
-        }
-      }
-
-      return { success: health.healthy, data: health };
-    } catch (error) {
-      output.printError(`Health check failed: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Logs command
-const logsCommand: Command = {
-  name: 'logs',
-  description: 'Show MCP server logs',
-  options: [
-    {
-      name: 'lines',
-      short: 'n',
-      description: 'Number of lines',
-      type: 'number',
-      default: 20
-    },
-    {
-      name: 'follow',
-      short: 'f',
-      description: 'Follow log output',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'level',
-      description: 'Filter by log level',
-      type: 'string',
-      choices: ['debug', 'info', 'warn', 'error']
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const lines = ctx.flags.lines as number;
-
-    // Simulated logs for now - would read from actual log file
-    const logs = [
-      { time: new Date().toISOString(), level: 'info', message: 'MCP Server started on stdio' },
-      { time: new Date().toISOString(), level: 'info', message: 'Registered 27 tools' },
-      { time: new Date().toISOString(), level: 'debug', message: 'Received request: tools/list' },
-      { time: new Date().toISOString(), level: 'info', message: 'Session initialized' },
-    ].slice(-lines);
-
-    output.writeln();
-    output.writeln(output.bold('MCP Server Logs'));
-    output.writeln();
-
-    for (const log of logs) {
-      let levelStr: string;
-      switch (log.level) {
-        case 'error':
-          levelStr = output.error(log.level.toUpperCase().padEnd(5));
-          break;
-        case 'warn':
-          levelStr = output.warning(log.level.toUpperCase().padEnd(5));
-          break;
-        case 'debug':
-          levelStr = output.dim(log.level.toUpperCase().padEnd(5));
-          break;
-        default:
-          levelStr = output.info(log.level.toUpperCase().padEnd(5));
-      }
-
-      output.writeln(`${output.dim(log.time)} ${levelStr} ${log.message}`);
-    }
-
-    return { success: true, data: logs };
-  }
-};
-
-// Restart command
-const restartCommand: Command = {
-  name: 'restart',
-  description: 'Restart MCP server',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force restart without graceful shutdown',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const force = ctx.flags.force as boolean;
-
-    output.printInfo('Restarting MCP Server...');
-
-    try {
-      const manager = getServerManager();
-      const status = await manager.restart();
-
-      output.printSuccess('MCP Server restarted');
-      output.writeln(output.dim(`  PID: ${status.pid}`));
-
-      return { success: true, data: status };
-    } catch (error) {
-      output.printError(`Failed to restart: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// Main MCP command
-export const mcpCommand: Command = {
-  name: 'mcp',
-  description: 'MCP server management',
-  subcommands: [
-    startCommand,
-    stopCommand,
-    statusCommand,
-    healthCommand,
-    restartCommand,
-    toolsCommand,
-    toggleCommand,
-    execCommand,
-    logsCommand
-  ],
-  options: [],
-  examples: [
-    { command: 'claude-flow mcp start', description: 'Start MCP server' },
-    { command: 'claude-flow mcp start -t http -p 8080', description: 'Start HTTP server on port 8080' },
-    { command: 'claude-flow mcp status', description: 'Show server status' },
-    { command: 'claude-flow mcp tools', description: 'List tools' },
-    { command: 'claude-flow mcp stop', description: 'Stop the server' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('MCP Server Management'));
-    output.writeln();
-    output.writeln('Usage: claude-flow mcp <subcommand> [options]');
-    output.writeln();
-    output.writeln('Subcommands:');
-    output.printList([
-      `${output.highlight('start')}    - Start MCP server`,
-      `${output.highlight('stop')}     - Stop MCP server`,
-      `${output.highlight('status')}   - Show server status`,
-      `${output.highlight('health')}   - Check server health`,
-      `${output.highlight('restart')}  - Restart MCP server`,
-      `${output.highlight('tools')}    - List available tools`,
-      `${output.highlight('toggle')}   - Enable/disable tools`,
-      `${output.highlight('exec')}     - Execute a tool`,
-      `${output.highlight('logs')}     - Show server logs`
-    ]);
-
-    return { success: true };
-  }
-};
-
-export default mcpCommand;