mcp-twin 1.2.0 → 1.3.0

package/dist/cloud/routes/twins.js

@@ -0,0 +1,740 @@
+"use strict";
+/**
+ * Twins Routes
+ * MCP Twin Cloud
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const db_1 = require("../db");
+const auth_1 = require("../auth");
+const twin_manager_1 = require("../../twin-manager");
+const router = (0, express_1.Router)();
+/**
+ * Middleware: Check quota
+ */
+async function checkQuota(req, res, next) {
+    try {
+        const user = req.user;
+        const limits = (0, auth_1.getTierLimits)(user.tier);
+        // Get current month usage
+        const startOfMonth = new Date();
+        startOfMonth.setDate(1);
+        startOfMonth.setHours(0, 0, 0, 0);
+        const usage = await (0, db_1.queryOne)(`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) {
+        console.error('[Twins] Quota check error:', error);
+        next(); // Don't block on quota check errors
+    }
+}
+/**
+ * POST /api/twins
+ * Create a new twin
+ */
+router.post('/', auth_1.authenticateApiKey, async (req, res) => {
+    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 = (0, auth_1.getTierLimits)(user.tier);
+        const twinCount = await (0, db_1.queryOne)('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 (0, db_1.query)(`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) {
+        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('/', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twins = await (0, db_1.query)(`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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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 (0, db_1.queryOne)('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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const { name, config } = req.body;
+        const updates = [];
+        const values = [];
+        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 (0, db_1.query)(`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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        // Stop twin if running
+        const twin = await (0, db_1.queryOne)('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 (0, db_1.query)('DELETE FROM twins WHERE id = $1', [twin.id]);
+        res.json({
+            message: 'Twin deleted',
+        });
+    }
+    catch (error) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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 = (0, twin_manager_1.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 (0, db_1.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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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 = (0, twin_manager_1.getTwinManager)();
+        await manager.stopTwins(twin.name);
+        // Update twin status
+        await (0, db_1.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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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 = (0, twin_manager_1.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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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 = (0, twin_manager_1.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 (0, db_1.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) {
+        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', auth_1.authenticateApiKey, checkQuota, async (req, res) => {
+    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 (0, db_1.queryOne)('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 = await response.json();
+        const durationMs = Date.now() - startTime;
+        const isError = !!result.error;
+        // Log the call
+        await (0, db_1.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 (0, db_1.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) {
+        const durationMs = Date.now() - startTime;
+        // Log the error
+        if (req.params.id && req.user) {
+            await (0, db_1.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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const { limit = '50', offset = '0', status } = req.query;
+        const twin = await (0, db_1.queryOne)('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 = [twin.id];
+        if (status) {
+            params.push(status);
+            whereClause += ` AND status = $${params.length}`;
+        }
+        params.push(parseInt(limit));
+        params.push(parseInt(offset));
+        const logs = await (0, db_1.query)(`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) {
+        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', auth_1.authenticateApiKey, async (req, res) => {
+    try {
+        const twin = await (0, db_1.queryOne)('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) {
+        console.error('[Twins] Status error:', error);
+        res.status(500).json({
+            error: {
+                code: 'INTERNAL_ERROR',
+                message: 'Failed to get status',
+            },
+        });
+    }
+});
+exports.default = router;
+//# sourceMappingURL=twins.js.map