mcp-twin 1.2.0 → 1.3.0

package/src/cloud/routes/usage.ts

@@ -0,0 +1,186 @@
+/**
+ * Usage Routes
+ * MCP Twin Cloud
+ */
+
+import { Router, Request, Response } from 'express';
+import { query, queryOne } from '../db';
+import { authenticateApiKey, getTierLimits } from '../auth';
+
+const router = Router();
+
+interface UsageDaily {
+  id: string;
+  user_id: string;
+  date: string;
+  request_count: number;
+  error_count: number;
+  total_duration_ms: number;
+}
+
+/**
+ * GET /api/usage
+ * Get current month usage
+ */
+router.get('/', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const user = req.user!;
+    const limits = getTierLimits(user.tier);
+
+    // Get current month start
+    const now = new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+
+    // Get aggregated usage for current month
+    const usage = await queryOne<{
+      total_requests: string;
+      total_errors: string;
+      total_duration: string;
+    }>(
+      `SELECT
+         COALESCE(SUM(request_count), 0) as total_requests,
+         COALESCE(SUM(error_count), 0) as total_errors,
+         COALESCE(SUM(total_duration_ms), 0) as total_duration
+       FROM usage_daily
+       WHERE user_id = $1 AND date >= $2 AND date <= $3`,
+      [user.id, startOfMonth.toISOString().split('T')[0], endOfMonth.toISOString().split('T')[0]]
+    );
+
+    // Get twin count
+    const twinCount = await queryOne<{ count: string }>(
+      'SELECT COUNT(*) as count FROM twins WHERE user_id = $1',
+      [user.id]
+    );
+
+    const totalRequests = parseInt(usage?.total_requests || '0');
+    const totalErrors = parseInt(usage?.total_errors || '0');
+    const twins = parseInt(twinCount?.count || '0');
+
+    res.json({
+      tier: user.tier,
+      period: {
+        start: startOfMonth.toISOString().split('T')[0],
+        end: endOfMonth.toISOString().split('T')[0],
+      },
+      twins: {
+        used: twins,
+        limit: limits.twins === -1 ? 'unlimited' : limits.twins,
+      },
+      requests: {
+        used: totalRequests,
+        limit: limits.requestsPerMonth === -1 ? 'unlimited' : limits.requestsPerMonth,
+        percentUsed: limits.requestsPerMonth === -1 ? 0 : Math.round((totalRequests / limits.requestsPerMonth) * 100),
+      },
+      errors: {
+        count: totalErrors,
+        rate: totalRequests > 0 ? Math.round((totalErrors / totalRequests) * 100) : 0,
+      },
+      avgLatencyMs: totalRequests > 0
+        ? Math.round(parseInt(usage?.total_duration || '0') / totalRequests)
+        : 0,
+    });
+  } catch (error: any) {
+    console.error('[Usage] Get error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get usage',
+      },
+    });
+  }
+});
+
+/**
+ * GET /api/usage/history
+ * Get usage history (daily breakdown)
+ */
+router.get('/history', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    const { days = '30' } = req.query;
+    const daysNum = Math.min(parseInt(days as string) || 30, 90);
+
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - daysNum);
+
+    const usage = await query<UsageDaily>(
+      `SELECT date, request_count, error_count, total_duration_ms
+       FROM usage_daily
+       WHERE user_id = $1 AND date >= $2
+       ORDER BY date DESC`,
+      [req.user!.id, startDate.toISOString().split('T')[0]]
+    );
+
+    res.json({
+      history: usage.map((u) => ({
+        date: u.date,
+        requests: u.request_count,
+        errors: u.error_count,
+        avgLatencyMs: u.request_count > 0
+          ? Math.round(u.total_duration_ms / u.request_count)
+          : 0,
+      })),
+    });
+  } catch (error: any) {
+    console.error('[Usage] Get history error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get usage history',
+      },
+    });
+  }
+});
+
+/**
+ * GET /api/usage/by-twin
+ * Get usage breakdown by twin
+ */
+router.get('/by-twin', authenticateApiKey, async (req: Request, res: Response) => {
+  try {
+    // Get current month
+    const now = new Date();
+    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+
+    const usage = await query<{
+      twin_id: string;
+      twin_name: string;
+      request_count: string;
+      error_count: string;
+      avg_duration: string;
+    }>(
+      `SELECT
+         t.id as twin_id,
+         t.name as twin_name,
+         COUNT(l.id) as request_count,
+         SUM(CASE WHEN l.status = 'error' THEN 1 ELSE 0 END) as error_count,
+         AVG(l.duration_ms) as avg_duration
+       FROM twins t
+       LEFT JOIN logs l ON l.twin_id = t.id AND l.created_at >= $2
+       WHERE t.user_id = $1
+       GROUP BY t.id, t.name
+       ORDER BY request_count DESC`,
+      [req.user!.id, startOfMonth.toISOString()]
+    );
+
+    res.json({
+      byTwin: usage.map((u) => ({
+        twinId: u.twin_id,
+        twinName: u.twin_name,
+        requests: parseInt(u.request_count || '0'),
+        errors: parseInt(u.error_count || '0'),
+        avgLatencyMs: Math.round(parseFloat(u.avg_duration || '0')),
+      })),
+    });
+  } catch (error: any) {
+    console.error('[Usage] Get by twin error:', error);
+    res.status(500).json({
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: 'Failed to get usage by twin',
+      },
+    });
+  }
+});
+
+export default router;

package/src/cloud/server.ts

@@ -0,0 +1,151 @@
+/**
+ * MCP Twin Cloud Server
+ * Zero-downtime MCP server management as a service
+ *
+ * Powered by Prax Chat - https://prax.chat
+ */
+
+import express, { Request, Response, NextFunction } from 'express';
+import cors from 'cors';
+import helmet from 'helmet';
+import { initializeDatabase, closePool } from './db';
+import authRoutes from './routes/auth';
+import twinRoutes from './routes/twins';
+import usageRoutes from './routes/usage';
+
+const app = express();
+const PORT = parseInt(process.env.PORT || '3000');
+const HOST = process.env.HOST || '0.0.0.0';
+
+// Middleware
+app.use(helmet());
+app.use(cors({
+  origin: process.env.CORS_ORIGIN || '*',
+  credentials: true,
+}));
+app.use(express.json({ limit: '10mb' }));
+
+// Request logging
+app.use((req: Request, res: Response, next: NextFunction) => {
+  const start = Date.now();
+  res.on('finish', () => {
+    const duration = Date.now() - start;
+    if (process.env.DEBUG_HTTP) {
+      console.log(`[HTTP] ${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
+    }
+  });
+  next();
+});
+
+// Health check
+app.get('/health', (req: Request, res: Response) => {
+  res.json({
+    status: 'healthy',
+    service: 'mcp-twin-cloud',
+    version: '1.2.0',
+    timestamp: new Date().toISOString(),
+  });
+});
+
+// API Routes
+app.use('/api/auth', authRoutes);
+app.use('/api/twins', twinRoutes);
+app.use('/api/usage', usageRoutes);
+
+// API documentation
+app.get('/api', (req: Request, res: Response) => {
+  res.json({
+    name: 'MCP Twin Cloud API',
+    version: '1.0.0',
+    documentation: 'https://prax.chat/mcp-twin/docs',
+    endpoints: {
+      auth: {
+        'POST /api/auth/signup': 'Create account',
+        'POST /api/auth/login': 'Login and get session token',
+        'GET /api/auth/me': 'Get current user info',
+        'POST /api/auth/api-keys': 'Create API key',
+        'GET /api/auth/api-keys': 'List API keys',
+        'DELETE /api/auth/api-keys/:id': 'Revoke API key',
+      },
+      twins: {
+        'POST /api/twins': 'Create twin',
+        'GET /api/twins': 'List twins',
+        'GET /api/twins/:id': 'Get twin details',
+        'PATCH /api/twins/:id': 'Update twin',
+        'DELETE /api/twins/:id': 'Delete twin',
+        'POST /api/twins/:id/start': 'Start twin',
+        'POST /api/twins/:id/stop': 'Stop twin',
+        'POST /api/twins/:id/reload': 'Reload standby',
+        'POST /api/twins/:id/swap': 'Swap active server',
+        'POST /api/twins/:id/call': 'Execute tool call',
+        'GET /api/twins/:id/logs': 'Get execution logs',
+        'GET /api/twins/:id/status': 'Get health status',
+      },
+      usage: {
+        'GET /api/usage': 'Get current month usage',
+        'GET /api/usage/history': 'Get usage history',
+        'GET /api/usage/by-twin': 'Get usage by twin',
+      },
+    },
+  });
+});
+
+// 404 handler
+app.use((req: Request, res: Response) => {
+  res.status(404).json({
+    error: {
+      code: 'NOT_FOUND',
+      message: `Route ${req.method} ${req.path} not found`,
+    },
+  });
+});
+
+// Error handler
+app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
+  console.error('[Server] Unhandled error:', err);
+  res.status(500).json({
+    error: {
+      code: 'INTERNAL_ERROR',
+      message: 'An unexpected error occurred',
+    },
+  });
+});
+
+// Start server
+export async function startServer(): Promise<void> {
+  console.log('─────────────────────────────────────────');
+  console.log('⚡ MCP Twin Cloud');
+  console.log('   Powered by Prax Chat');
+  console.log('─────────────────────────────────────────');
+  console.log('');
+
+  // Initialize database
+  await initializeDatabase();
+  console.log('[Server] Database initialized');
+
+  // Start listening
+  app.listen(PORT, HOST, () => {
+    console.log(`[Server] Listening on http://${HOST}:${PORT}`);
+    console.log('');
+    console.log('API Endpoints:');
+    console.log(`  Health:  http://${HOST}:${PORT}/health`);
+    console.log(`  Docs:    http://${HOST}:${PORT}/api`);
+    console.log(`  Auth:    http://${HOST}:${PORT}/api/auth/*`);
+    console.log(`  Twins:   http://${HOST}:${PORT}/api/twins/*`);
+    console.log(`  Usage:   http://${HOST}:${PORT}/api/usage/*`);
+    console.log('');
+    console.log('─────────────────────────────────────────');
+  });
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    console.log('\n[Server] Shutting down...');
+    await closePool();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+export default app;