mcp-twin 1.2.0

package/src/index.ts

@@ -0,0 +1,309 @@
+/**
+ * MCP Twin Plugin - Entry Point
+ * Zero-downtime MCP server updates for Claude Code
+ *
+ * Powered by Prax - https://prax.chat
+ */
+
+import { getTwinManager, MCPTwinManager } from './twin-manager';
+import { detectMCPServers, generateTwinConfig, autoConfigureTwins } from './config-detector';
+
+export { MCPTwinManager, getTwinManager };
+export { detectMCPServers, generateTwinConfig, autoConfigureTwins };
+
+// Branding
+const PRAX_FOOTER = '\n─────────────────────────────────────────\n⚡ Powered by Prax Chat | prax.chat/mcp-twin';
+
+/**
+ * Plugin Commands
+ */
+export const commands = {
+  /**
+   * /twin start [server]
+   */
+  async start(serverName?: string): Promise<string> {
+    const manager = getTwinManager();
+
+    if (!serverName) {
+      // Show available servers
+      const status = await manager.status();
+      const available = status.available || [];
+
+      if (available.length === 0) {
+        return `No MCP servers configured.
+
+Run auto-detect to find servers:
+  /twin detect
+
+Or add manually:
+  /twin add <name> <script-path>`;
+      }
+
+      return `Available servers:
+${available.map((s: string) => `  - ${s}`).join('\n')}
+
+Start twins:
+  /twin start <server-name>`;
+    }
+
+    const result = await manager.startTwins(serverName);
+
+    if (!result.ok) {
+      return `Failed to start twins: ${result.error}`;
+    }
+
+    return `Started twins for ${serverName}
+
+  Server A: port ${result.pidA ? result.statusA : 'failed'} ${result.statusA === 'running' ? '●' : '○'}
+  Server B: port ${result.pidB ? result.statusB : 'failed'} ${result.statusB === 'running' ? '●' : '○'}
+  Active: A
+
+${result.hint}${PRAX_FOOTER}`;
+  },
+
+  /**
+   * /twin stop [server]
+   */
+  async stop(serverName?: string): Promise<string> {
+    const manager = getTwinManager();
+
+    if (!serverName) {
+      return `Usage: /twin stop <server-name>
+
+Or stop all: /twin stop --all`;
+    }
+
+    if (serverName === '--all') {
+      const status = await manager.status();
+      const running = Object.keys(status.twins || {});
+
+      if (running.length === 0) {
+        return 'No twins running.';
+      }
+
+      const results: string[] = [];
+      for (const name of running) {
+        const result = await manager.stopTwins(name);
+        results.push(`  ${name}: ${result.ok ? 'stopped' : 'failed'}`);
+      }
+
+      return `Stopped all twins:\n${results.join('\n')}`;
+    }
+
+    const result = await manager.stopTwins(serverName);
+
+    if (!result.ok) {
+      return `Failed to stop: ${result.error}`;
+    }
+
+    return `Stopped ${serverName} twins
+
+  Server A: stopped
+  Server B: stopped`;
+  },
+
+  /**
+   * /twin reload <server>
+   */
+  async reload(serverName: string): Promise<string> {
+    if (!serverName) {
+      return 'Usage: /twin reload <server-name>';
+    }
+
+    const manager = getTwinManager();
+    const result = await manager.reloadStandby(serverName);
+
+    if (!result.ok) {
+      return `Reload failed: ${result.error}
+
+${result.hint || ''}`;
+    }
+
+    return `Reloaded ${serverName} standby
+
+  ${result.reloaded}
+  Health: ${result.healthy ? 'passing ●' : 'FAILED ○'}
+  Reload count: ${result.reloadCount}
+
+${result.hint}`;
+  },
+
+  /**
+   * /twin swap <server>
+   */
+  async swap(serverName: string): Promise<string> {
+    if (!serverName) {
+      return 'Usage: /twin swap <server-name>';
+    }
+
+    const manager = getTwinManager();
+    const result = await manager.swapActive(serverName);
+
+    if (!result.ok) {
+      return `Swap failed: ${result.error}
+
+${result.hint || ''}`;
+    }
+
+    return `Swapped ${serverName}
+
+  Previous: ${result.previousActive}
+  Now active: ${result.newActive}
+
+${result.hint}${PRAX_FOOTER}`;
+  },
+
+  /**
+   * /twin status [server]
+   */
+  async status(serverName?: string): Promise<string> {
+    const manager = getTwinManager();
+    const result = await manager.status(serverName);
+
+    if (!result.ok) {
+      return `Error: ${result.error}`;
+    }
+
+    if (serverName) {
+      // Detailed single server status
+      const { serverA, serverB, active, reloadCount, lastSwap } = result;
+
+      return `${serverName} Twin Status
+${'═'.repeat(40)}
+
+Server A (port ${serverA.port})
+  State: ${serverA.state}
+  Health: ${serverA.healthy ? 'healthy ●' : 'unhealthy ○'}
+  ${serverA.isActive ? '← ACTIVE' : '  standby'}
+
+Server B (port ${serverB.port})
+  State: ${serverB.state}
+  Health: ${serverB.healthy ? 'healthy ●' : 'unhealthy ○'}
+  ${serverB.isActive ? '← ACTIVE' : '  standby'}
+
+Reloads: ${reloadCount}
+Last swap: ${lastSwap ? new Date(lastSwap).toLocaleTimeString() : 'never'}`;
+    }
+
+    // All twins summary
+    const twins = result.twins || {};
+    const twinNames = Object.keys(twins);
+
+    if (twinNames.length === 0) {
+      const available = result.available || [];
+      return `No twins running.
+
+Available servers:
+${available.map((s: string) => `  - ${s}`).join('\n')}
+
+Start with: /twin start <server>`;
+    }
+
+    let output = `MCP Twin Status
+${'═'.repeat(40)}
+
+`;
+
+    for (const [name, info] of Object.entries(twins) as [string, any][]) {
+      const activeLabel = info.active.toUpperCase();
+      const [healthA, healthB] = info.healthy;
+
+      output += `${name}
+  Active: ${activeLabel} (${info.ports[info.active === 'a' ? 0 : 1]}) ${healthA || healthB ? '●' : '○'}
+  Standby: ${info.active === 'a' ? 'B' : 'A'} (${info.ports[info.active === 'a' ? 1 : 0]}) ${(info.active === 'a' ? healthB : healthA) ? '●' : '○'}
+  Reloads: ${info.reloadCount}
+
+`;
+    }
+
+    const notRunning = (result.available || []).filter((s: string) => !twins[s]);
+    if (notRunning.length > 0) {
+      output += `Not running: ${notRunning.join(', ')}`;
+    }
+
+    return output;
+  },
+
+  /**
+   * /twin detect - Auto-detect MCP servers
+   */
+  async detect(): Promise<string> {
+    const result = autoConfigureTwins();
+
+    if (result.detected === 0) {
+      return `No MCP servers found in Claude config.
+
+Add servers manually:
+  /twin add <name> <script-path> <port1> <port2>`;
+    }
+
+    return `Detected ${result.detected} MCP servers:
+${result.servers.map(s => `  - ${s}`).join('\n')}
+
+${result.configured} configured for twins.
+
+Start twins:
+  /twin start <server-name>`;
+  },
+
+  /**
+   * /twin help
+   */
+  help(): string {
+    return `MCP Twin - Zero-Downtime Server Updates
+${'═'.repeat(44)}
+
+Commands:
+  /twin start [server]   Start twin servers
+  /twin stop [server]    Stop twin servers
+  /twin reload <server>  Reload standby with new code
+  /twin swap <server>    Switch traffic to standby
+  /twin status [server]  Show twin status
+  /twin detect           Auto-detect MCP servers
+  /twin help             Show this help
+
+Workflow:
+  1. /twin start my-server  → Start A (active) + B (standby)
+  2. Edit your server code
+  3. /twin reload my-server → Update standby B
+  4. /twin swap my-server   → Switch to B
+  5. Keep coding - no restart needed!
+${PRAX_FOOTER}
+
+Pro features coming soon: prax.chat/mcp-twin/pro`;
+  }
+};
+
+/**
+ * Main command router
+ */
+export async function handleCommand(args: string[]): Promise<string> {
+  const [subcommand, ...rest] = args;
+
+  switch (subcommand?.toLowerCase()) {
+    case 'start':
+      return commands.start(rest[0]);
+    case 'stop':
+      return commands.stop(rest[0]);
+    case 'reload':
+      return commands.reload(rest[0]);
+    case 'swap':
+      return commands.swap(rest[0]);
+    case 'status':
+      return commands.status(rest[0]);
+    case 'detect':
+      return commands.detect();
+    case 'help':
+    case undefined:
+      return commands.help();
+    default:
+      return `Unknown command: ${subcommand}\n\nRun /twin help for usage.`;
+  }
+}
+
+export default {
+  commands,
+  handleCommand,
+  getTwinManager,
+  detectMCPServers
+};