mcp-twin 1.2.0 → 1.3.0

package/src/cloud/routes/twins.ts

@@ -0,0 +1,908 @@
+/**
+ * Twins Routes
+ * MCP Twin Cloud
+ */
+
+import { Router, Request, Response } from 'express';
+import { query, queryOne } from '../db';
+import { authenticateApiKey, getTierLimits } from '../auth';
+import { getTwinManager } from '../../twin-manager';
+
+const router = Router();
+
+interface Twin {
+  id: string;
+  user_id: string;
+  name: string;
+  config_json: any;
+  status: string;
+  active_server: string;
+  port_a: number | null;
+  port_b: number | null;
+  pid_a: number | null;
+  pid_b: number | null;
+  created_at: Date;
+  updated_at: Date;
+}
+
+interface Log {
+  id: string;
+  user_id: string;
+  twin_id: string;
+  tool_name: string;
+  args: any;
+  result: any;
+  error: string | null;
+  status: string;
+  duration_ms: number;
+  server: string;
+  created_at: Date;
+}
+
+/**
+ * Middleware: Check quota
+ */
+async function checkQuota(req: Request, res: Response, next: Function): Promise<void> {
+  try {
+    const user = req.user!;
+    const limits = getTierLimits(user.tier);
+
+    // Get current month usage
+    const startOfMonth = new Date();
+    startOfMonth.setDate(1);
+    startOfMonth.setHours(0, 0, 0, 0);
+
+    const usage = await queryOne<{ total: string }>(
+      `SELECT COALESCE(SUM(request_count), 0) as total
+       FROM usage_daily
+       WHERE user_id = $1 AND date >= $2`,
+      [user.id, startOfMonth.toISOString().split('T')[0]]
+    );
+
+    const usedRequests = parseInt(usage?.total || '0');
+
+    if (limits.requestsPerMonth !== -1 && usedRequests >= limits.requestsPerMonth) {
+      res.status(429).json({
+        error: {
+          code: 'QUOTA_EXCEEDED',
+          message: `Monthly request quota exceeded (${usedRequests}/${limits.requestsPerMonth}). Upgrade to Pro for more requests.`,
+          usage: {
+            used: usedRequests,
+            limit: limits.requestsPerMonth,
+          },
+        },
+      });
+      return;
+    }
+
+    next();
+  } catch (error: any) {
+    console.error('[Twins] Quota check error:', error);
+    next(); // Don't block on quota check errors
+  }
+}
+
+/**
+ * POST /api/twins
+ * Create a new twin
+ */
+router.post('/', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const { name, config } = req.body;
+    const user = req.user!;
+
+    // Validate input
+    if (!name || !config) {
+      res.status(400).json({
+        error: {
+          code: 'VALIDATION_ERROR',
+          message: 'Name and config are required',
+        },
+      });
+      return;
+    }
+
+    // Check twin limit
+    const limits = getTierLimits(user.tier);
+    const twinCount = await queryOne<{ count: string }>(
+      'SELECT COUNT(*) as count FROM twins WHERE user_id = $1',
+      [user.id]
+    );
+
+    const currentCount = parseInt(twinCount?.count || '0');
+    if (limits.twins !== -1 && currentCount >= limits.twins) {
+      res.status(403).json({
+        error: {
+          code: 'TWIN_LIMIT_REACHED',
+          message: `Twin limit reached (${currentCount}/${limits.twins}). Upgrade to create more twins.`,
+        },
+      });
+      return;
+    }
+
+    // Assign ports (simple strategy: use twin count * 2 + base)
+    const basePort = 8100 + (currentCount * 2);
+    const portA = basePort;
+    const portB = basePort + 1;
+
+    // Create twin
+    const twins = await query<Twin>(
+      `INSERT INTO twins (user_id, name, config_json, port_a, port_b)
+       VALUES ($1, $2, $3, $4, $5)
+       RETURNING *`,
+      [user.id, name, JSON.stringify(config), portA, portB]
+    );
+
+    const twin = twins[0];
+
+    res.status(201).json({
+      message: 'Twin created',
+      twin: {
+        id: twin.id,
+        name: twin.name,
+        config: twin.config_json,
+        status: twin.status,
+        activeServer: twin.active_server,
+        ports: {
+          a: twin.port_a,
+          b: twin.port_b,
+        },
+        createdAt: twin.created_at,
+      },
+    });
+  } catch (error: any) {
+    console.error('[Twins] Create error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to create twin',
+      },
+    });
+  }
+});
+
+/**
+ * GET /api/twins
+ * List user's twins
+ */
+router.get('/', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twins = await query<Twin>(
+      `SELECT * FROM twins WHERE user_id = $1 ORDER BY created_at DESC`,
+      [req.user!.id]
+    );
+
+    res.json({
+      twins: twins.map((t) => ({
+        id: t.id,
+        name: t.name,
+        config: t.config_json,
+        status: t.status,
+        activeServer: t.active_server,
+        ports: {
+          a: t.port_a,
+          b: t.port_b,
+        },
+        createdAt: t.created_at,
+        updatedAt: t.updated_at,
+      })),
+    });
+  } catch (error: any) {
+    console.error('[Twins] List error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to list twins',
+      },
+    });
+  }
+});
+
+/**
+ * GET /api/twins/:id
+ * Get twin details
+ */
+router.get('/:id', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    // Get recent logs count
+    const logCount = await queryOne<{ count: string }>(
+      'SELECT COUNT(*) as count FROM logs WHERE twin_id = $1',
+      [twin.id]
+    );
+
+    res.json({
+      twin: {
+        id: twin.id,
+        name: twin.name,
+        config: twin.config_json,
+        status: twin.status,
+        activeServer: twin.active_server,
+        ports: {
+          a: twin.port_a,
+          b: twin.port_b,
+        },
+        pids: {
+          a: twin.pid_a,
+          b: twin.pid_b,
+        },
+        createdAt: twin.created_at,
+        updatedAt: twin.updated_at,
+      },
+      stats: {
+        totalCalls: parseInt(logCount?.count || '0'),
+      },
+    });
+  } catch (error: any) {
+    console.error('[Twins] Get error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get twin',
+      },
+    });
+  }
+});
+
+/**
+ * PATCH /api/twins/:id
+ * Update twin config
+ */
+router.patch('/:id', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const { name, config } = req.body;
+
+    const updates: string[] = [];
+    const values: any[] = [];
+    let paramIndex = 1;
+
+    if (name !== undefined) {
+      updates.push(`name = $${paramIndex++}`);
+      values.push(name);
+    }
+
+    if (config !== undefined) {
+      updates.push(`config_json = $${paramIndex++}`);
+      values.push(JSON.stringify(config));
+    }
+
+    if (updates.length === 0) {
+      res.status(400).json({
+        error: {
+          code: 'VALIDATION_ERROR',
+          message: 'No fields to update',
+        },
+      });
+      return;
+    }
+
+    updates.push(`updated_at = NOW()`);
+    values.push(req.params.id, req.user!.id);
+
+    const twins = await query<Twin>(
+      `UPDATE twins
+       SET ${updates.join(', ')}
+       WHERE id = $${paramIndex++} AND user_id = $${paramIndex}
+       RETURNING *`,
+      values
+    );
+
+    if (twins.length === 0) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    const twin = twins[0];
+
+    res.json({
+      message: 'Twin updated',
+      twin: {
+        id: twin.id,
+        name: twin.name,
+        config: twin.config_json,
+        status: twin.status,
+        updatedAt: twin.updated_at,
+      },
+    });
+  } catch (error: any) {
+    console.error('[Twins] Update error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to update twin',
+      },
+    });
+  }
+});
+
+/**
+ * DELETE /api/twins/:id
+ * Delete a twin
+ */
+router.delete('/:id', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    // Stop twin if running
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    // Delete (cascade will remove logs)
+    await query('DELETE FROM twins WHERE id = $1', [twin.id]);
+
+    res.json({
+      message: 'Twin deleted',
+    });
+  } catch (error: any) {
+    console.error('[Twins] Delete error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to delete twin',
+      },
+    });
+  }
+});
+
+/**
+ * POST /api/twins/:id/start
+ * Start a twin
+ */
+router.post('/:id/start', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    if (twin.status === 'running') {
+      res.status(400).json({
+        error: {
+          code: 'ALREADY_RUNNING',
+          message: 'Twin is already running',
+        },
+      });
+      return;
+    }
+
+    // Start using twin manager
+    const manager = getTwinManager();
+    const result = await manager.startTwins(twin.name);
+
+    if (!result.ok) {
+      res.status(500).json({
+        error: {
+          code: 'START_FAILED',
+          message: result.error || 'Failed to start twin',
+        },
+      });
+      return;
+    }
+
+    // Update twin status
+    await query(
+      `UPDATE twins SET status = 'running', pid_a = $1, pid_b = $2, updated_at = NOW()
+       WHERE id = $3`,
+      [result.pidA, result.pidB, twin.id]
+    );
+
+    res.json({
+      message: 'Twin started',
+      status: 'running',
+      servers: {
+        a: { port: twin.port_a, pid: result.pidA, status: result.statusA },
+        b: { port: twin.port_b, pid: result.pidB, status: result.statusB },
+      },
+    });
+  } catch (error: any) {
+    console.error('[Twins] Start error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to start twin',
+      },
+    });
+  }
+});
+
+/**
+ * POST /api/twins/:id/stop
+ * Stop a twin
+ */
+router.post('/:id/stop', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    // Stop using twin manager
+    const manager = getTwinManager();
+    await manager.stopTwins(twin.name);
+
+    // Update twin status
+    await query(
+      `UPDATE twins SET status = 'stopped', pid_a = NULL, pid_b = NULL, updated_at = NOW()
+       WHERE id = $1`,
+      [twin.id]
+    );
+
+    res.json({
+      message: 'Twin stopped',
+      status: 'stopped',
+    });
+  } catch (error: any) {
+    console.error('[Twins] Stop error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to stop twin',
+      },
+    });
+  }
+});
+
+/**
+ * POST /api/twins/:id/reload
+ * Reload twin standby
+ */
+router.post('/:id/reload', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    if (twin.status !== 'running') {
+      res.status(400).json({
+        error: {
+          code: 'NOT_RUNNING',
+          message: 'Twin must be running to reload',
+        },
+      });
+      return;
+    }
+
+    // Reload using twin manager
+    const manager = getTwinManager();
+    const result = await manager.reloadStandby(twin.name);
+
+    if (!result.ok) {
+      res.status(500).json({
+        error: {
+          code: 'RELOAD_FAILED',
+          message: result.error || 'Failed to reload twin',
+        },
+      });
+      return;
+    }
+
+    res.json({
+      message: 'Twin reloaded',
+      reloaded: result.reloaded,
+      healthy: result.healthy,
+      reloadCount: result.reloadCount,
+    });
+  } catch (error: any) {
+    console.error('[Twins] Reload error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to reload twin',
+      },
+    });
+  }
+});
+
+/**
+ * POST /api/twins/:id/swap
+ * Swap twin active server
+ */
+router.post('/:id/swap', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    if (twin.status !== 'running') {
+      res.status(400).json({
+        error: {
+          code: 'NOT_RUNNING',
+          message: 'Twin must be running to swap',
+        },
+      });
+      return;
+    }
+
+    // Swap using twin manager
+    const manager = getTwinManager();
+    const result = await manager.swapActive(twin.name);
+
+    if (!result.ok) {
+      res.status(500).json({
+        error: {
+          code: 'SWAP_FAILED',
+          message: result.error || 'Failed to swap twin',
+        },
+      });
+      return;
+    }
+
+    // Update active server
+    const newActive = twin.active_server === 'a' ? 'b' : 'a';
+    await query(
+      `UPDATE twins SET active_server = $1, updated_at = NOW() WHERE id = $2`,
+      [newActive, twin.id]
+    );
+
+    res.json({
+      message: 'Twin swapped',
+      previousActive: result.previousActive,
+      newActive: result.newActive,
+    });
+  } catch (error: any) {
+    console.error('[Twins] Swap error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to swap twin',
+      },
+    });
+  }
+});
+
+/**
+ * POST /api/twins/:id/call
+ * Execute a tool call through the twin
+ */
+router.post('/:id/call', authenticateApiKey, checkQuota, async (req: Request, res: Response) => {
+  const startTime = Date.now();
+
+  try {
+    const { toolName, args } = req.body;
+
+    if (!toolName) {
+      res.status(400).json({
+        error: {
+          code: 'VALIDATION_ERROR',
+          message: 'toolName is required',
+        },
+      });
+      return;
+    }
+
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    if (twin.status !== 'running') {
+      res.status(400).json({
+        error: {
+          code: 'NOT_RUNNING',
+          message: 'Twin must be running to execute calls',
+        },
+      });
+      return;
+    }
+
+    // Determine active port
+    const activePort = twin.active_server === 'a' ? twin.port_a : twin.port_b;
+
+    // Make HTTP call to MCP server
+    const response = await fetch(`http://localhost:${activePort}/mcp`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'tools/call',
+        params: { name: toolName, arguments: args || {} },
+        id: Date.now(),
+      }),
+    });
+
+    const result: any = await response.json();
+    const durationMs = Date.now() - startTime;
+    const isError = !!result.error;
+
+    // Log the call
+    await query(
+      `INSERT INTO logs (user_id, twin_id, tool_name, args, result, error, status, duration_ms, server)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+      [
+        req.user!.id,
+        twin.id,
+        toolName,
+        JSON.stringify(args || {}),
+        isError ? null : JSON.stringify(result.result),
+        isError ? JSON.stringify(result.error) : null,
+        isError ? 'error' : 'success',
+        durationMs,
+        twin.active_server,
+      ]
+    );
+
+    // Update usage
+    const today = new Date().toISOString().split('T')[0];
+    await query(
+      `INSERT INTO usage_daily (user_id, date, request_count, error_count, total_duration_ms)
+       VALUES ($1, $2, 1, $3, $4)
+       ON CONFLICT (user_id, date)
+       DO UPDATE SET
+         request_count = usage_daily.request_count + 1,
+         error_count = usage_daily.error_count + $3,
+         total_duration_ms = usage_daily.total_duration_ms + $4`,
+      [req.user!.id, today, isError ? 1 : 0, durationMs]
+    );
+
+    if (isError) {
+      res.status(500).json({
+        error: {
+          code: 'TOOL_ERROR',
+          message: result.error.message || 'Tool call failed',
+          details: result.error,
+        },
+        durationMs,
+        server: twin.active_server,
+      });
+      return;
+    }
+
+    res.json({
+      result: result.result,
+      durationMs,
+      server: twin.active_server,
+      requestId: `req_${Date.now()}`,
+    });
+  } catch (error: any) {
+    const durationMs = Date.now() - startTime;
+
+    // Log the error
+    if (req.params.id && req.user) {
+      await query(
+        `INSERT INTO logs (user_id, twin_id, tool_name, args, error, status, duration_ms, server)
+         VALUES ($1, $2, $3, $4, $5, 'error', $6, 'a')`,
+        [
+          req.user.id,
+          req.params.id,
+          req.body?.toolName || 'unknown',
+          JSON.stringify(req.body?.args || {}),
+          error.message,
+          durationMs,
+        ]
+      ).catch(() => {}); // Don't fail on logging errors
+    }
+
+    console.error('[Twins] Call error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to execute tool call',
+        details: error.message,
+      },
+      durationMs,
+    });
+  }
+});
+
+/**
+ * GET /api/twins/:id/logs
+ * Get twin execution logs
+ */
+router.get('/:id/logs', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const { limit = '50', offset = '0', status } = req.query;
+
+    const twin = await queryOne<Twin>(
+      'SELECT id FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    let whereClause = 'WHERE twin_id = $1';
+    const params: any[] = [twin.id];
+
+    if (status) {
+      params.push(status);
+      whereClause += ` AND status = $${params.length}`;
+    }
+
+    params.push(parseInt(limit as string));
+    params.push(parseInt(offset as string));
+
+    const logs = await query<Log>(
+      `SELECT * FROM logs
+       ${whereClause}
+       ORDER BY created_at DESC
+       LIMIT $${params.length - 1} OFFSET $${params.length}`,
+      params
+    );
+
+    res.json({
+      logs: logs.map((l) => ({
+        id: l.id,
+        toolName: l.tool_name,
+        args: l.args,
+        result: l.result,
+        error: l.error,
+        status: l.status,
+        durationMs: l.duration_ms,
+        server: l.server,
+        createdAt: l.created_at,
+      })),
+    });
+  } catch (error: any) {
+    console.error('[Twins] Get logs error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get logs',
+      },
+    });
+  }
+});
+
+/**
+ * GET /api/twins/:id/status
+ * Get twin health status
+ */
+router.get('/:id/status', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const twin = await queryOne<Twin>(
+      'SELECT * FROM twins WHERE id = $1 AND user_id = $2',
+      [req.params.id, req.user!.id]
+    );
+
+    if (!twin) {
+      res.status(404).json({
+        error: {
+          code: 'NOT_FOUND',
+          message: 'Twin not found',
+        },
+      });
+      return;
+    }
+
+    // Check health if running
+    let healthA = false;
+    let healthB = false;
+
+    if (twin.status === 'running') {
+      try {
+        const respA = await fetch(`http://localhost:${twin.port_a}/health`, {
+          signal: AbortSignal.timeout(2000)
+        });
+        healthA = respA.ok;
+      } catch {}
+
+      try {
+        const respB = await fetch(`http://localhost:${twin.port_b}/health`, {
+          signal: AbortSignal.timeout(2000)
+        });
+        healthB = respB.ok;
+      } catch {}
+    }
+
+    res.json({
+      twin: {
+        id: twin.id,
+        name: twin.name,
+        status: twin.status,
+        activeServer: twin.active_server,
+      },
+      servers: {
+        a: {
+          port: twin.port_a,
+          pid: twin.pid_a,
+          healthy: healthA,
+          isActive: twin.active_server === 'a',
+        },
+        b: {
+          port: twin.port_b,
+          pid: twin.pid_b,
+          healthy: healthB,
+          isActive: twin.active_server === 'b',
+        },
+      },
+    });
+  } catch (error: any) {
+    console.error('[Twins] Status error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get status',
+      },
+    });
+  }
+});
+
+export default router;