mcp-twin 1.2.0 → 1.4.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,171 @@
+/**
+ * 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';
+import billingRoutes from './routes/billing';
+import { isStripeConfigured } from './stripe';
+
+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,
+}));
+
+// Raw body for Stripe webhooks (must be before json parser)
+app.use('/api/billing/webhook', express.raw({ type: 'application/json' }));
+
+// JSON parser for all other routes
+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.4.0',
+    timestamp: new Date().toISOString(),
+    stripe: isStripeConfigured(),
+  });
+});
+
+// API Routes
+app.use('/api/auth', authRoutes);
+app.use('/api/twins', twinRoutes);
+app.use('/api/usage', usageRoutes);
+app.use('/api/billing', billingRoutes);
+
+// 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',
+      },
+      billing: {
+        'GET /api/billing/status': 'Get billing status',
+        'GET /api/billing/plans': 'Get available plans',
+        'POST /api/billing/checkout': 'Create Stripe checkout session',
+        'POST /api/billing/portal': 'Create billing portal session',
+        'GET /api/billing/invoices': 'Get invoices',
+        'POST /api/billing/webhook': 'Stripe webhook endpoint',
+      },
+    },
+  });
+});
+
+// 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(`  Billing:  http://${HOST}:${PORT}/api/billing/*`);
+    console.log('');
+    console.log(`Stripe: ${isStripeConfigured() ? 'configured' : 'not configured (set STRIPE_SECRET_KEY)'}`);
+    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;

package/src/cloud/stripe.ts

@@ -0,0 +1,192 @@
+/**
+ * Stripe Integration
+ * MCP Twin Cloud
+ */
+
+import Stripe from 'stripe';
+
+// Initialize Stripe
+const stripeSecretKey = process.env.STRIPE_SECRET_KEY;
+
+let stripe: Stripe | null = null;
+
+export function getStripe(): Stripe {
+  if (!stripe) {
+    if (!stripeSecretKey) {
+      throw new Error('STRIPE_SECRET_KEY environment variable is required');
+    }
+    stripe = new Stripe(stripeSecretKey);
+  }
+  return stripe;
+}
+
+export function isStripeConfigured(): boolean {
+  return !!stripeSecretKey;
+}
+
+// Price IDs - Set these in your Stripe dashboard
+export const PRICE_IDS = {
+  starter_monthly: process.env.STRIPE_PRICE_STARTER || 'price_starter_monthly',
+  pro_monthly: process.env.STRIPE_PRICE_PRO || 'price_pro_monthly',
+};
+
+// Tier mapping from Stripe price to our tier
+export const PRICE_TO_TIER: Record<string, string> = {
+  [PRICE_IDS.starter_monthly]: 'starter',
+  [PRICE_IDS.pro_monthly]: 'pro',
+};
+
+// Tier to price mapping
+export const TIER_TO_PRICE: Record<string, string> = {
+  starter: PRICE_IDS.starter_monthly,
+  pro: PRICE_IDS.pro_monthly,
+};
+
+/**
+ * Create or get Stripe customer for user
+ */
+export async function getOrCreateCustomer(
+  userId: string,
+  email: string,
+  existingCustomerId?: string | null
+): Promise<string> {
+  const stripe = getStripe();
+
+  if (existingCustomerId) {
+    return existingCustomerId;
+  }
+
+  const customer = await stripe.customers.create({
+    email,
+    metadata: {
+      userId,
+    },
+  });
+
+  return customer.id;
+}
+
+/**
+ * Create a checkout session for subscription
+ */
+export async function createCheckoutSession(
+  customerId: string,
+  priceId: string,
+  successUrl: string,
+  cancelUrl: string
+): Promise<Stripe.Checkout.Session> {
+  const stripe = getStripe();
+
+  const session = await stripe.checkout.sessions.create({
+    customer: customerId,
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price: priceId,
+        quantity: 1,
+      },
+    ],
+    mode: 'subscription',
+    success_url: successUrl,
+    cancel_url: cancelUrl,
+    allow_promotion_codes: true,
+  });
+
+  return session;
+}
+
+/**
+ * Create a billing portal session
+ */
+export async function createPortalSession(
+  customerId: string,
+  returnUrl: string
+): Promise<Stripe.BillingPortal.Session> {
+  const stripe = getStripe();
+
+  const session = await stripe.billingPortal.sessions.create({
+    customer: customerId,
+    return_url: returnUrl,
+  });
+
+  return session;
+}
+
+/**
+ * Get subscription details
+ */
+export async function getSubscription(
+  subscriptionId: string
+): Promise<Stripe.Subscription | null> {
+  const stripe = getStripe();
+
+  try {
+    const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+    return subscription;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Cancel subscription
+ */
+export async function cancelSubscription(
+  subscriptionId: string,
+  immediately: boolean = false
+): Promise<Stripe.Subscription> {
+  const stripe = getStripe();
+
+  if (immediately) {
+    return stripe.subscriptions.cancel(subscriptionId);
+  }
+
+  // Cancel at period end
+  return stripe.subscriptions.update(subscriptionId, {
+    cancel_at_period_end: true,
+  });
+}
+
+/**
+ * Get customer's invoices
+ */
+export async function getInvoices(
+  customerId: string,
+  limit: number = 10
+): Promise<Stripe.Invoice[]> {
+  const stripe = getStripe();
+
+  const invoices = await stripe.invoices.list({
+    customer: customerId,
+    limit,
+  });
+
+  return invoices.data;
+}
+
+/**
+ * Construct webhook event from request
+ */
+export function constructWebhookEvent(
+  payload: Buffer,
+  signature: string,
+  webhookSecret: string
+): Stripe.Event {
+  const stripe = getStripe();
+  return stripe.webhooks.constructEvent(payload, signature, webhookSecret);
+}
+
+export default {
+  getStripe,
+  isStripeConfigured,
+  getOrCreateCustomer,
+  createCheckoutSession,
+  createPortalSession,
+  getSubscription,
+  cancelSubscription,
+  getInvoices,
+  constructWebhookEvent,
+  PRICE_IDS,
+  PRICE_TO_TIER,
+  TIER_TO_PRICE,
+};