mcp-twin 1.2.0

package/src/cli.ts

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+/**
+ * MCP Twin CLI - Universal zero-downtime MCP server management
+ *
+ * Works with ANY MCP client: Claude Desktop, VS Code, Cursor, Cline, etc.
+ *
+ * Usage:
+ *   npx mcp-twin start my-server
+ *   npx mcp-twin reload my-server
+ *   npx mcp-twin swap my-server
+ *   npx mcp-twin status
+ *
+ * Powered by Prax Chat - https://prax.chat
+ */
+
+import { getTwinManager } from './twin-manager';
+import { autoConfigureTwins } from './config-detector';
+
+const PRAX_FOOTER = '\n─────────────────────────────────────────\n⚡ Powered by Prax Chat | prax.chat/mcp-twin';
+
+const VERSION = '1.2.0';
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0]?.toLowerCase();
+  const serverName = args[1];
+
+  const manager = getTwinManager();
+
+  switch (command) {
+    case 'start': {
+      if (!serverName) {
+        const status = await manager.status();
+        console.log('Available servers:');
+        (status.available || []).forEach((s: string) => console.log(`  - ${s}`));
+        console.log('\nUsage: mcp-twin start <server-name>');
+        break;
+      }
+      const result = await manager.startTwins(serverName);
+      if (result.ok) {
+        console.log(`✓ Started twins for ${serverName}`);
+        console.log(`  Server A: port ${result.portA} (${result.statusA})`);
+        console.log(`  Server B: port ${result.portB} (${result.statusB})`);
+        console.log(`  Active: A`);
+      } else {
+        console.error(`✗ Failed: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(PRAX_FOOTER);
+      break;
+    }
+
+    case 'stop': {
+      if (!serverName) {
+        console.log('Usage: mcp-twin stop <server-name>');
+        console.log('       mcp-twin stop --all');
+        break;
+      }
+      if (serverName === '--all') {
+        const status = await manager.status();
+        for (const name of Object.keys(status.twins || {})) {
+          await manager.stopTwins(name);
+          console.log(`✓ Stopped ${name}`);
+        }
+      } else {
+        const result = await manager.stopTwins(serverName);
+        if (result.ok) {
+          console.log(`✓ Stopped ${serverName} twins`);
+        } else {
+          console.error(`✗ Failed: ${result.error}`);
+          process.exit(1);
+        }
+      }
+      break;
+    }
+
+    case 'reload': {
+      if (!serverName) {
+        console.log('Usage: mcp-twin reload <server-name>');
+        break;
+      }
+      console.log(`Reloading ${serverName} standby...`);
+      const result = await manager.reloadStandby(serverName);
+      if (result.ok) {
+        console.log(`✓ Reloaded ${result.reloaded}`);
+        console.log(`  Health: ${result.healthy ? 'passing ●' : 'FAILED ○'}`);
+        console.log(`  Reload count: ${result.reloadCount}`);
+        if (result.healthy) {
+          console.log(`\nReady to swap: mcp-twin swap ${serverName}`);
+        }
+      } else {
+        console.error(`✗ Failed: ${result.error}`);
+        process.exit(1);
+      }
+      console.log(PRAX_FOOTER);
+      break;
+    }
+
+    case 'swap': {
+      if (!serverName) {
+        console.log('Usage: mcp-twin swap <server-name>');
+        break;
+      }
+      const result = await manager.swapActive(serverName);
+      if (result.ok) {
+        console.log(`✓ Swapped ${serverName}`);
+        console.log(`  Previous: ${result.previousActive}`);
+        console.log(`  Now active: ${result.newActive}`);
+      } else {
+        console.error(`✗ Failed: ${result.error}`);
+        if (result.hint) console.log(`  Hint: ${result.hint}`);
+        process.exit(1);
+      }
+      console.log(PRAX_FOOTER);
+      break;
+    }
+
+    case 'status': {
+      const result = await manager.status(serverName);
+      if (serverName && result.ok) {
+        console.log(`${serverName} Twin Status`);
+        console.log('═'.repeat(40));
+        console.log(`\nServer A (port ${result.serverA.port})`);
+        console.log(`  State: ${result.serverA.state}`);
+        console.log(`  Health: ${result.serverA.healthy ? 'healthy ●' : 'unhealthy ○'}`);
+        console.log(`  ${result.serverA.isActive ? '← ACTIVE' : '  standby'}`);
+        console.log(`\nServer B (port ${result.serverB.port})`);
+        console.log(`  State: ${result.serverB.state}`);
+        console.log(`  Health: ${result.serverB.healthy ? 'healthy ●' : 'unhealthy ○'}`);
+        console.log(`  ${result.serverB.isActive ? '← ACTIVE' : '  standby'}`);
+        console.log(`\nReloads: ${result.reloadCount}`);
+      } else if (result.ok) {
+        console.log('MCP Twin Status');
+        console.log('═'.repeat(40));
+        const twins = result.twins || {};
+        if (Object.keys(twins).length === 0) {
+          console.log('\nNo twins running.');
+          console.log('\nAvailable servers:');
+          (result.available || []).forEach((s: string) => console.log(`  - ${s}`));
+        } else {
+          for (const [name, info] of Object.entries(twins) as [string, any][]) {
+            const activePort = info.ports[info.active === 'a' ? 0 : 1];
+            console.log(`\n${name}`);
+            console.log(`  Active: ${info.active.toUpperCase()} (port ${activePort}) ${info.healthy[info.active === 'a' ? 0 : 1] ? '●' : '○'}`);
+            console.log(`  Reloads: ${info.reloadCount}`);
+          }
+        }
+      }
+      break;
+    }
+
+    case 'detect': {
+      console.log('Detecting MCP servers...');
+      const result = autoConfigureTwins();
+      if (result.detected === 0) {
+        console.log('No MCP servers found.');
+        console.log('\nSearched:');
+        console.log('  - Claude Desktop: ~/Library/Application Support/Claude/');
+        console.log('  - Claude Code: ~/.claude/');
+        console.log('  - VS Code: .vscode/mcp.json');
+        console.log('  - Cursor: ~/.cursor/mcp.json');
+      } else {
+        console.log(`✓ Detected ${result.detected} MCP servers:`);
+        result.servers.forEach((s: string) => console.log(`  - ${s}`));
+        console.log(`\n${result.configured} configured for twins.`);
+      }
+      break;
+    }
+
+    case 'version':
+    case '-v':
+    case '--version': {
+      console.log(`MCP Twin v${VERSION}`);
+      console.log('Powered by Prax Chat - https://prax.chat');
+      break;
+    }
+
+    case 'help':
+    case '-h':
+    case '--help':
+    default: {
+      console.log(`
+MCP Twin v${VERSION} - Zero-Downtime MCP Server Updates
+${'═'.repeat(50)}
+
+Works with: Claude Desktop, VS Code, Cursor, Cline, Windsurf
+
+Commands:
+  mcp-twin start <server>    Start twin servers
+  mcp-twin stop <server>     Stop twin servers (--all for all)
+  mcp-twin reload <server>   Reload standby with new code
+  mcp-twin swap <server>     Switch traffic to standby
+  mcp-twin status [server]   Show twin status
+  mcp-twin detect            Auto-detect MCP servers
+  mcp-twin help              Show this help
+
+Workflow:
+  1. mcp-twin start my-server  → Start A (active) + B (standby)
+  2. Edit your server code
+  3. mcp-twin reload my-server → Update standby B
+  4. mcp-twin swap my-server   → Switch to B (zero downtime!)
+
+Config: ~/.mcp-twin/config.json
+Logs:   ~/.mcp-twin/logs/
+${PRAX_FOOTER}
+
+Pro features: prax.chat/mcp-twin/pro
+`);
+      break;
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/src/config-detector.ts

@@ -0,0 +1,340 @@
+/**
+ * Config Detector - Auto-detect MCP servers from multiple MCP clients
+ *
+ * Supports:
+ * - Claude Desktop
+ * - Claude Code
+ * - VS Code (GitHub Copilot)
+ * - Cursor
+ * - Cline
+ * - Windsurf
+ *
+ * Powered by Prax Chat - https://prax.chat
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+interface MCPServerEntry {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+interface MCPConfig {
+  mcpServers?: Record<string, MCPServerEntry>;
+  servers?: Record<string, MCPServerEntry>;  // VS Code/Cursor format
+}
+
+export interface DetectedServer {
+  name: string;
+  command: string;
+  args: string[];
+  scriptPath: string | null;
+  language: 'python' | 'node' | 'unknown';
+  source: string;  // Which client config it came from
+}
+
+/**
+ * Get all possible MCP config paths for different clients
+ */
+function getAllConfigPaths(): { client: string; path: string }[] {
+  const platform = os.platform();
+  const home = os.homedir();
+  const cwd = process.cwd();
+
+  const paths: { client: string; path: string }[] = [];
+
+  // Claude Desktop
+  if (platform === 'darwin') {
+    paths.push({
+      client: 'Claude Desktop',
+      path: path.join(home, 'Library/Application Support/Claude/claude_desktop_config.json')
+    });
+  } else if (platform === 'win32') {
+    paths.push({
+      client: 'Claude Desktop',
+      path: path.join(home, 'AppData/Roaming/Claude/claude_desktop_config.json')
+    });
+  } else {
+    paths.push({
+      client: 'Claude Desktop',
+      path: path.join(home, '.config/claude/claude_desktop_config.json')
+    });
+  }
+
+  // Claude Code
+  paths.push({
+    client: 'Claude Code',
+    path: path.join(home, '.claude/claude_desktop_config.json')
+  });
+
+  // VS Code - workspace
+  paths.push({
+    client: 'VS Code (workspace)',
+    path: path.join(cwd, '.vscode/mcp.json')
+  });
+
+  // VS Code - user settings (macOS)
+  if (platform === 'darwin') {
+    paths.push({
+      client: 'VS Code (user)',
+      path: path.join(home, 'Library/Application Support/Code/User/settings.json')
+    });
+  }
+
+  // Cursor - workspace
+  paths.push({
+    client: 'Cursor (workspace)',
+    path: path.join(cwd, '.cursor/mcp.json')
+  });
+
+  // Cursor - global
+  paths.push({
+    client: 'Cursor (global)',
+    path: path.join(home, '.cursor/mcp.json')
+  });
+
+  // Windsurf
+  paths.push({
+    client: 'Windsurf',
+    path: path.join(home, '.windsurf/mcp.json')
+  });
+
+  // Cline (VS Code extension, uses VS Code settings)
+  // Already covered by VS Code paths
+
+  return paths;
+}
+
+/**
+ * Get path to Claude desktop config (legacy, for backwards compatibility)
+ */
+function getClaudeConfigPath(): string {
+  const platform = os.platform();
+
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library/Application Support/Claude/claude_desktop_config.json');
+  } else if (platform === 'win32') {
+    return path.join(os.homedir(), 'AppData/Roaming/Claude/claude_desktop_config.json');
+  } else {
+    // Linux
+    return path.join(os.homedir(), '.config/claude/claude_desktop_config.json');
+  }
+}
+
+/**
+ * Extract script path from command args
+ */
+function extractScriptPath(command: string, args: string[]): string | null {
+  // Common patterns:
+  // python3 /path/to/server.py
+  // node /path/to/server.js
+  // npx ts-node /path/to/server.ts
+
+  for (const arg of args) {
+    // Skip flags
+    if (arg.startsWith('-')) continue;
+
+    // Check if it's a file path
+    const expanded = arg.replace('~', os.homedir());
+    if (fs.existsSync(expanded)) {
+      return expanded;
+    }
+
+    // Check common extensions
+    if (arg.endsWith('.py') || arg.endsWith('.js') || arg.endsWith('.ts')) {
+      return arg.replace('~', os.homedir());
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detect language from command
+ */
+function detectLanguage(command: string): 'python' | 'node' | 'unknown' {
+  const cmd = command.toLowerCase();
+
+  if (cmd.includes('python') || cmd.includes('python3')) {
+    return 'python';
+  }
+  if (cmd.includes('node') || cmd.includes('npx') || cmd.includes('tsx')) {
+    return 'node';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Assign deterministic ports based on server name
+ */
+export function assignPorts(serverName: string): [number, number] {
+  // Simple hash function
+  let hash = 0;
+  for (let i = 0; i < serverName.length; i++) {
+    const char = serverName.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+
+  // Map to port range 8100-8298 (99 server pairs)
+  const basePort = 8100 + (Math.abs(hash) % 100) * 2;
+  return [basePort, basePort + 1];
+}
+
+/**
+ * Detect MCP servers from all supported MCP clients
+ */
+export function detectMCPServers(): DetectedServer[] {
+  const allPaths = getAllConfigPaths();
+  const servers: DetectedServer[] = [];
+  const seen = new Set<string>();  // Dedupe by server name
+
+  for (const { client, path: configPath } of allPaths) {
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+
+    try {
+      const config: MCPConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+      // Support both mcpServers (Claude) and servers (VS Code/Cursor) formats
+      const mcpServers = config.mcpServers || config.servers || {};
+
+      for (const [name, entry] of Object.entries(mcpServers)) {
+        // Skip if already seen (first config wins)
+        if (seen.has(name)) continue;
+        seen.add(name);
+
+        const args = entry.args || [];
+        const scriptPath = extractScriptPath(entry.command, args);
+        const language = detectLanguage(entry.command);
+
+        servers.push({
+          name,
+          command: entry.command,
+          args,
+          scriptPath,
+          language,
+          source: client
+        });
+      }
+    } catch (err) {
+      // Skip invalid configs silently
+      continue;
+    }
+  }
+
+  return servers;
+}
+
+/**
+ * Detect MCP servers from Claude config only (legacy)
+ */
+export function detectMCPServersFromClaude(): DetectedServer[] {
+  const configPath = getClaudeConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return [];
+  }
+
+  try {
+    const config: MCPConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const servers: DetectedServer[] = [];
+
+    if (!config.mcpServers) {
+      return [];
+    }
+
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      const args = entry.args || [];
+      const scriptPath = extractScriptPath(entry.command, args);
+      const language = detectLanguage(entry.command);
+
+      servers.push({
+        name,
+        command: entry.command,
+        args,
+        scriptPath,
+        language,
+        source: 'Claude Desktop'
+      });
+    }
+
+    return servers;
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Generate twin config from detected servers
+ */
+export function generateTwinConfig(servers: DetectedServer[]): Record<string, any> {
+  const config: Record<string, any> = {};
+
+  for (const server of servers) {
+    if (!server.scriptPath) {
+      console.log(`[ConfigDetector] Skipping ${server.name}: no script path found`);
+      continue;
+    }
+
+    const [portA, portB] = assignPorts(server.name);
+
+    config[server.name] = {
+      script: server.scriptPath,
+      ports: [portA, portB],
+      healthEndpoint: '/health',
+      startupTimeout: 10,
+      python: server.language === 'python' ? server.command : 'python3'
+    };
+  }
+
+  return config;
+}
+
+/**
+ * Auto-detect and update twin config
+ */
+export function autoConfigureTwins(): { detected: number; configured: number; servers: string[] } {
+  const detected = detectMCPServers();
+  const twinConfig = generateTwinConfig(detected);
+
+  return {
+    detected: detected.length,
+    configured: Object.keys(twinConfig).length,
+    servers: Object.keys(twinConfig)
+  };
+}
+
+// CLI test
+if (require.main === module) {
+  console.log('Detecting MCP servers...\n');
+
+  const servers = detectMCPServers();
+
+  if (servers.length === 0) {
+    console.log('No MCP servers found in Claude config.');
+  } else {
+    console.log(`Found ${servers.length} servers:\n`);
+
+    for (const server of servers) {
+      console.log(`  ${server.name}`);
+      console.log(`    Command: ${server.command}`);
+      console.log(`    Script: ${server.scriptPath || '(not found)'}`);
+      console.log(`    Language: ${server.language}`);
+      console.log(`    Ports: ${assignPorts(server.name).join(', ')}`);
+      console.log();
+    }
+  }
+}
+
+export default {
+  detectMCPServers,
+  generateTwinConfig,
+  autoConfigureTwins,
+  assignPorts
+};