agent-relay 1.2.0 → 1.3.0

package/dist/cloud/api/billing.js

@@ -5,24 +5,121 @@
  */
 import { Router } from 'express';
 import { getBillingService, getAllPlans, getPlan, comparePlans } from '../billing/index.js';
-import { getConfig } from '../config.js';
+import { getConfig, isAdminUser } from '../config.js';
+import { db } from '../db/index.js';
+import { requireAuth } from './auth.js';
+import { getProvisioner, RESOURCE_TIERS } from '../provisioner/index.js';
+import { getResourceTierForPlan } from '../services/planLimits.js';
 export const billingRouter = Router();
 /**
- * Middleware to require authentication
+ * Get the count of connected agents in a running workspace
+ * Returns 0 if workspace is not reachable or has no agents
  */
-function requireAuth(req, res, next) {
-    if (!req.session?.user) {
-        res.status(401).json({ error: 'Authentication required' });
-        return;
+async function getWorkspaceAgentCount(publicUrl) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch(`${publicUrl}/agents`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!response.ok)
+            return 0;
+        const data = await response.json();
+        return data.agents?.length ?? 0;
+    }
+    catch {
+        // Workspace not reachable or error - assume no agents
+        return 0;
     }
-    next();
+}
+/**
+ * Resize user's workspaces to match their new plan tier
+ * Called after plan upgrade/downgrade to adjust compute resources
+ *
+ * Strategy:
+ * - Stopped workspaces: Resize immediately (no disruption)
+ * - Running workspaces with no agents: Resize immediately (safe to restart)
+ * - Running workspaces with agents: Save config for next restart (no agent disruption)
+ *
+ * Returns info about which workspaces were deferred so we can inform the user.
+ */
+async function resizeWorkspacesForPlan(userId, newPlan) {
+    const result = { resized: 0, deferred: [], failed: 0 };
+    try {
+        const workspaces = await db.workspaces.findByUserId(userId);
+        if (workspaces.length === 0)
+            return result;
+        const provisioner = getProvisioner();
+        const targetTierName = getResourceTierForPlan(newPlan);
+        const targetTier = RESOURCE_TIERS[targetTierName];
+        console.log(`[billing] Upgrading ${workspaces.length} workspace(s) for user ${userId.substring(0, 8)} to ${targetTierName}`);
+        for (const workspace of workspaces) {
+            if (workspace.status !== 'running' && workspace.status !== 'stopped') {
+                console.log(`[billing] Skipping workspace ${workspace.id.substring(0, 8)} (status: ${workspace.status})`);
+                continue;
+            }
+            try {
+                let skipRestart = false;
+                let agentCount = 0;
+                // For running workspaces: check if there are active agents
+                if (workspace.status === 'running' && workspace.publicUrl) {
+                    agentCount = await getWorkspaceAgentCount(workspace.publicUrl);
+                    if (agentCount > 0) {
+                        // Has active agents - don't disrupt them
+                        skipRestart = true;
+                        console.log(`[billing] Workspace ${workspace.id.substring(0, 8)} has ${agentCount} active agent(s), deferring resize`);
+                    }
+                    else {
+                        // No active agents - safe to restart immediately
+                        console.log(`[billing] Workspace ${workspace.id.substring(0, 8)} has no active agents, proceeding with immediate resize`);
+                    }
+                }
+                await provisioner.resize(workspace.id, targetTier, skipRestart);
+                if (skipRestart) {
+                    console.log(`[billing] Queued resize for workspace ${workspace.id.substring(0, 8)} to ${targetTierName} (will apply on next restart)`);
+                    result.deferred.push({
+                        workspaceId: workspace.id,
+                        workspaceName: workspace.name,
+                        agentCount,
+                    });
+                }
+                else {
+                    console.log(`[billing] Resized workspace ${workspace.id.substring(0, 8)} to ${targetTierName}`);
+                    result.resized++;
+                }
+            }
+            catch (error) {
+                console.error(`[billing] Failed to resize workspace ${workspace.id}:`, error);
+                result.failed++;
+                // Continue with other workspaces even if one fails
+            }
+        }
+    }
+    catch (error) {
+        console.error('[billing] Failed to resize workspaces:', error);
+    }
+    return result;
 }
 /**
  * GET /api/billing/plans
  * Get all available billing plans
  */
 billingRouter.get('/plans', (req, res) => {
-    const plans = getAllPlans();
+    const rawPlans = getAllPlans();
+    // Transform plans to frontend format
+    const plans = rawPlans.map((plan) => ({
+        tier: plan.id,
+        name: plan.name,
+        description: plan.description,
+        price: {
+            monthly: plan.priceMonthly / 100, // Convert cents to dollars
+            yearly: plan.priceYearly / 100,
+        },
+        features: plan.features,
+        limits: plan.limits,
+        recommended: plan.id === 'pro',
+    }));
     // Add publishable key for frontend
     const config = getConfig();
     res.json({
@@ -67,15 +164,38 @@ billingRouter.get('/compare', (req, res) => {
  * Get current user's subscription status
  */
 billingRouter.get('/subscription', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    const billing = getBillingService();
+    const userId = req.session.userId;
     try {
+        // Fetch user from database
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        // Admin users have special status - show their current plan without Stripe
+        if (isAdminUser(user.githubUsername)) {
+            return res.json({
+                tier: user.plan || 'enterprise',
+                subscription: null,
+                customer: null,
+                isAdmin: true,
+            });
+        }
+        // If user doesn't have a Stripe customer ID, use the database plan value
+        // This handles manually-set plans and prevents hanging on Stripe API calls
+        if (!user.stripeCustomerId) {
+            return res.json({
+                tier: user.plan || 'free',
+                subscription: null,
+                customer: null,
+            });
+        }
+        const billing = getBillingService();
         // Get or create Stripe customer
         const customerId = user.stripeCustomerId ||
-            await billing.getOrCreateCustomer(user.id, user.email, user.name);
-        // Save customer ID to session if newly created
+            await billing.getOrCreateCustomer(user.id, user.email || '', user.githubUsername);
+        // Save customer ID to database if newly created
         if (!user.stripeCustomerId) {
-            req.session.user.stripeCustomerId = customerId;
+            await db.users.update(userId, { stripeCustomerId: customerId });
         }
         // Get customer details
         const customer = await billing.getCustomer(customerId);
@@ -87,8 +207,11 @@ billingRouter.get('/subscription', requireAuth, async (req, res) => {
             });
             return;
         }
+        // Use Stripe subscription tier if active, otherwise fall back to database plan value
+        // This allows manual plan overrides in the database to take effect
+        const tier = customer.subscription?.tier || user.plan || 'free';
         res.json({
-            tier: customer.subscription?.tier || 'free',
+            tier,
             subscription: customer.subscription,
             customer: {
                 id: customer.id,
@@ -109,7 +232,7 @@ billingRouter.get('/subscription', requireAuth, async (req, res) => {
  * Create a checkout session for subscription
  */
 billingRouter.post('/checkout', requireAuth, async (req, res) => {
-    const user = req.session.user;
+    const userId = req.session.userId;
     const { tier, interval = 'month' } = req.body;
     if (!tier || !['pro', 'team', 'enterprise'].includes(tier)) {
         res.status(400).json({ error: 'Invalid tier' });
@@ -119,18 +242,44 @@ billingRouter.post('/checkout', requireAuth, async (req, res) => {
         res.status(400).json({ error: 'Invalid billing interval' });
         return;
     }
-    const billing = getBillingService();
     const config = getConfig();
     try {
+        // Fetch user from database
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        // Admin users get free upgrades - skip Stripe entirely
+        if (isAdminUser(user.githubUsername)) {
+            // Update user plan directly
+            await db.users.update(userId, { plan: tier });
+            console.log(`[billing] Admin user ${user.githubUsername} upgraded to ${tier} (free)`);
+            // Resize workspaces to match new plan (wait for result to inform user)
+            const resizeResult = await resizeWorkspacesForPlan(userId, tier);
+            // Build success URL with deferred workspace info if any
+            let successUrl = `${config.appUrl}/billing/success?admin=true`;
+            if (resizeResult.deferred.length > 0) {
+                // Encode deferred workspaces info for the frontend to display
+                const deferredInfo = encodeURIComponent(JSON.stringify(resizeResult.deferred));
+                successUrl += `&deferred=${deferredInfo}`;
+            }
+            // Return a fake session that redirects to success
+            return res.json({
+                sessionId: 'admin-upgrade',
+                checkoutUrl: successUrl,
+                resizeResult, // Also include in response for API consumers
+            });
+        }
+        const billing = getBillingService();
         // Get or create customer
         const customerId = user.stripeCustomerId ||
-            await billing.getOrCreateCustomer(user.id, user.email, user.name);
-        // Save customer ID to session
+            await billing.getOrCreateCustomer(user.id, user.email || '', user.githubUsername);
+        // Save customer ID to database
         if (!user.stripeCustomerId) {
-            req.session.user.stripeCustomerId = customerId;
+            await db.users.update(userId, { stripeCustomerId: customerId });
         }
         // Create checkout session
-        const session = await billing.createCheckoutSession(customerId, tier, interval, `${config.publicUrl}/billing/success?session_id={CHECKOUT_SESSION_ID}`, `${config.publicUrl}/billing/canceled`);
+        const session = await billing.createCheckoutSession(customerId, tier, interval, `${config.appUrl}/billing/success?session_id={CHECKOUT_SESSION_ID}`, `${config.appUrl}/billing/canceled`);
         res.json(session);
     }
     catch (error) {
@@ -143,15 +292,19 @@ billingRouter.post('/checkout', requireAuth, async (req, res) => {
  * Create a billing portal session for managing subscription
  */
 billingRouter.post('/portal', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    if (!user.stripeCustomerId) {
-        res.status(400).json({ error: 'No billing account found' });
-        return;
-    }
-    const billing = getBillingService();
-    const config = getConfig();
+    const userId = req.session.userId;
     try {
-        const session = await billing.createPortalSession(user.stripeCustomerId, `${config.publicUrl}/billing`);
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        if (!user.stripeCustomerId) {
+            res.status(400).json({ error: 'No billing account found' });
+            return;
+        }
+        const billing = getBillingService();
+        const config = getConfig();
+        const session = await billing.createPortalSession(user.stripeCustomerId, `${config.appUrl}/billing`);
         res.json(session);
     }
     catch (error) {
@@ -164,18 +317,22 @@ billingRouter.post('/portal', requireAuth, async (req, res) => {
  * Change subscription tier
  */
 billingRouter.post('/change', requireAuth, async (req, res) => {
-    const user = req.session.user;
+    const userId = req.session.userId;
     const { tier, interval = 'month' } = req.body;
     if (!tier || !['free', 'pro', 'team', 'enterprise'].includes(tier)) {
         res.status(400).json({ error: 'Invalid tier' });
         return;
     }
-    if (!user.stripeCustomerId) {
-        res.status(400).json({ error: 'No billing account found' });
-        return;
-    }
-    const billing = getBillingService();
     try {
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        if (!user.stripeCustomerId) {
+            res.status(400).json({ error: 'No billing account found' });
+            return;
+        }
+        const billing = getBillingService();
         // Get current subscription
         const customer = await billing.getCustomer(user.stripeCustomerId);
         if (!customer?.subscription) {
@@ -202,13 +359,17 @@ billingRouter.post('/change', requireAuth, async (req, res) => {
  * Cancel subscription at period end
  */
 billingRouter.post('/cancel', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    if (!user.stripeCustomerId) {
-        res.status(400).json({ error: 'No billing account found' });
-        return;
-    }
-    const billing = getBillingService();
+    const userId = req.session.userId;
     try {
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        if (!user.stripeCustomerId) {
+            res.status(400).json({ error: 'No billing account found' });
+            return;
+        }
+        const billing = getBillingService();
         const customer = await billing.getCustomer(user.stripeCustomerId);
         if (!customer?.subscription) {
             res.status(400).json({ error: 'No active subscription' });
@@ -230,13 +391,17 @@ billingRouter.post('/cancel', requireAuth, async (req, res) => {
  * Resume a canceled subscription
  */
 billingRouter.post('/resume', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    if (!user.stripeCustomerId) {
-        res.status(400).json({ error: 'No billing account found' });
-        return;
-    }
-    const billing = getBillingService();
+    const userId = req.session.userId;
     try {
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        if (!user.stripeCustomerId) {
+            res.status(400).json({ error: 'No billing account found' });
+            return;
+        }
+        const billing = getBillingService();
         const customer = await billing.getCustomer(user.stripeCustomerId);
         if (!customer?.subscription) {
             res.status(400).json({ error: 'No subscription to resume' });
@@ -259,13 +424,17 @@ billingRouter.post('/resume', requireAuth, async (req, res) => {
  * Get user's invoices
  */
 billingRouter.get('/invoices', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    if (!user.stripeCustomerId) {
-        res.json({ invoices: [] });
-        return;
-    }
-    const billing = getBillingService();
+    const userId = req.session.userId;
     try {
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        // No Stripe customer = no invoices, skip Stripe call entirely
+        if (!user.stripeCustomerId) {
+            return res.json({ invoices: [] });
+        }
+        const billing = getBillingService();
         const customer = await billing.getCustomer(user.stripeCustomerId);
         res.json({ invoices: customer?.invoices || [] });
     }
@@ -279,13 +448,17 @@ billingRouter.get('/invoices', requireAuth, async (req, res) => {
  * Get upcoming invoice preview
  */
 billingRouter.get('/upcoming', requireAuth, async (req, res) => {
-    const user = req.session.user;
-    if (!user.stripeCustomerId) {
-        res.json({ invoice: null });
-        return;
-    }
-    const billing = getBillingService();
+    const userId = req.session.userId;
     try {
+        const user = await db.users.findById(userId);
+        if (!user) {
+            return res.status(404).json({ error: 'User not found' });
+        }
+        if (!user.stripeCustomerId) {
+            res.json({ invoice: null });
+            return;
+        }
+        const billing = getBillingService();
         const invoice = await billing.getUpcomingInvoice(user.stripeCustomerId);
         res.json({ invoice });
     }
@@ -315,8 +488,14 @@ billingRouter.post('/webhook',
     }
     const billing = getBillingService();
     try {
-        // Get raw body
-        const rawBody = JSON.stringify(req.body);
+        // Use the preserved raw body from express.json verify callback
+        // This is critical for Stripe signature verification - JSON.stringify(req.body) won't work
+        const rawBody = req.rawBody;
+        if (!rawBody) {
+            console.error('Raw body not available for Stripe webhook verification');
+            res.status(400).json({ error: 'Raw body not available' });
+            return;
+        }
         // Verify and parse event
         const event = billing.verifyWebhookSignature(rawBody, sig);
         // Process the event
@@ -330,16 +509,48 @@ billingRouter.post('/webhook',
         // Handle specific events
         switch (billingEvent.type) {
             case 'subscription.created':
-            case 'subscription.updated':
-                // Update user's subscription in database
-                // This would integrate with your user/database layer
-                console.log('Subscription updated for user:', billingEvent.userId);
+            case 'subscription.updated': {
+                // Extract subscription tier and update user's plan
+                if (billingEvent.userId) {
+                    const subscription = billingEvent.data;
+                    const tier = billing.getTierFromSubscription(subscription);
+                    // Update user's plan in database
+                    await db.users.update(billingEvent.userId, { plan: tier });
+                    console.log(`Updated user ${billingEvent.userId} plan to: ${tier}`);
+                    // Resize workspaces to match new plan (async, don't block webhook)
+                    resizeWorkspacesForPlan(billingEvent.userId, tier).then((result) => {
+                        if (result.deferred.length > 0) {
+                            console.log(`[billing] User ${billingEvent.userId} upgrade: ${result.resized} resized, ${result.deferred.length} deferred (have active agents)`);
+                            result.deferred.forEach((d) => {
+                                console.log(`[billing]   - "${d.workspaceName}" has ${d.agentCount} agent(s), will resize on next restart`);
+                            });
+                        }
+                        else {
+                            console.log(`[billing] User ${billingEvent.userId} upgrade: all ${result.resized} workspace(s) resized immediately`);
+                        }
+                    }).catch((err) => {
+                        console.error(`Failed to resize workspaces for user ${billingEvent.userId}:`, err);
+                    });
+                }
+                else {
+                    console.warn('Subscription event received without userId:', billingEvent.id);
+                }
                 break;
-            case 'subscription.canceled':
-                console.log('Subscription canceled for user:', billingEvent.userId);
+            }
+            case 'subscription.canceled': {
+                // Reset user to free plan
+                if (billingEvent.userId) {
+                    await db.users.update(billingEvent.userId, { plan: 'free' });
+                    console.log(`User ${billingEvent.userId} subscription canceled, reset to free plan`);
+                    // Resize workspaces down to free tier (async)
+                    resizeWorkspacesForPlan(billingEvent.userId, 'free').catch((err) => {
+                        console.error(`Failed to resize workspaces for user ${billingEvent.userId}:`, err);
+                    });
+                }
                 break;
+            }
             case 'invoice.payment_failed':
-                // Notify user of failed payment
+                // Log payment failure (don't immediately downgrade - Stripe retries)
                 console.log('Payment failed for user:', billingEvent.userId);
                 break;
         }

package/dist/cloud/api/codex-auth-helper.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Codex Auth Helper API
+ *
+ * Provides endpoints for the `npx agent-relay codex-auth` CLI command.
+ * Uses SSH tunneling to forward localhost:1455 to the workspace container,
+ * allowing the Codex CLI's OAuth callback to work in remote/container environments.
+ *
+ * Flow:
+ * 1. CLI gets workspace SSH info via /tunnel-info
+ * 2. CLI establishes SSH tunnel: local:1455 -> container:1455
+ * 3. User completes OAuth, browser redirects to localhost:1455
+ * 4. Tunnel forwards to container's Codex CLI server
+ * 5. Codex CLI exchanges code for tokens internally
+ * 6. CLI polls for auth completion
+ */
+export declare const codexAuthHelperRouter: import("express-serve-static-core").Router;
+/**
+ * Stop the cleanup interval. Call this on server shutdown.
+ */
+export declare function stopCodexAuthCleanup(): void;
+//# sourceMappingURL=codex-auth-helper.d.ts.map