agent-relay 1.6.0 → 2.0.4

package/packages/cloud/dist/api/test-helpers.js

@@ -0,0 +1,745 @@
+/**
+ * Test Helper API Routes
+ *
+ * These endpoints are ONLY available in test/development mode.
+ * They allow integration tests to create users and daemons without OAuth.
+ *
+ * IMPORTANT: These routes are disabled in production (NODE_ENV=production).
+ */
+import { Router } from 'express';
+import { randomUUID, createHash, randomBytes } from 'crypto';
+import { getDb } from '../db/drizzle.js';
+import { users, linkedDaemons, workspaces, repositories } from '../db/schema.js';
+import { getProvisioner } from '../provisioner/index.js';
+import { db } from '../db/index.js';
+import { nangoService } from '../services/nango.js';
+export const testHelpersRouter = Router();
+// Only enable in test/development mode
+const isTestMode = process.env.NODE_ENV !== 'production';
+if (!isTestMode) {
+    console.warn('[test-helpers] Test helper routes are disabled in production');
+}
+/**
+ * POST /api/test/create-user
+ * Creates a test user without OAuth
+ */
+testHelpersRouter.post('/create-user', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { email, name } = req.body;
+        const db = getDb();
+        const testId = `test-${randomUUID()}`;
+        // Create user with required GitHub fields
+        const [user] = await db.insert(users).values({
+            email: email || `${testId}@test.local`,
+            githubId: testId,
+            githubUsername: name || 'test-user',
+            avatarUrl: null,
+        }).returning();
+        // Create session
+        const sessionId = randomUUID();
+        req.session.userId = user.id;
+        // Get session cookie (simplified for testing)
+        const sessionCookie = `connect.sid=s%3A${sessionId}`;
+        res.json({
+            userId: user.id,
+            email: user.email,
+            sessionCookie,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test user:', error);
+        res.status(500).json({ error: 'Failed to create test user' });
+    }
+});
+/**
+ * POST /api/test/create-daemon
+ * Creates a test daemon with API key
+ */
+testHelpersRouter.post('/create-daemon', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, machineId } = req.body;
+        if (!name) {
+            return res.status(400).json({ error: 'name is required' });
+        }
+        const db = getDb();
+        // First, ensure we have a test user to associate with the daemon
+        let [testUser] = await db.select().from(users).limit(1);
+        if (!testUser) {
+            // Create a test user if none exists
+            const testId = `test-system-${randomUUID()}`;
+            [testUser] = await db.insert(users).values({
+                email: `${testId}@test.local`,
+                githubId: testId,
+                githubUsername: 'test-system-user',
+                avatarUrl: null,
+            }).returning();
+        }
+        // Generate API key
+        const apiKey = `ar_live_${randomBytes(32).toString('hex')}`;
+        const apiKeyHash = createHash('sha256').update(apiKey).digest('hex');
+        // Create daemon - only include fields that exist in schema
+        const [daemon] = await db.insert(linkedDaemons).values({
+            userId: testUser.id,
+            name,
+            machineId: machineId || randomUUID(),
+            apiKeyHash,
+            status: 'online',
+            metadata: {
+                hostname: 'test-host',
+                platform: 'linux',
+                version: '1.0.0-test',
+            },
+        }).returning();
+        res.json({
+            daemonId: daemon.id,
+            apiKey,
+            name: daemon.name,
+            machineId: daemon.machineId,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test daemon:', error);
+        res.status(500).json({ error: 'Failed to create test daemon' });
+    }
+});
+/**
+ * POST /api/test/create-workspace
+ * Creates a test workspace for integration tests with optional linked repository
+ */
+testHelpersRouter.post('/create-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, repoFullName, userId: providedUserId } = req.body;
+        const db = getDb();
+        // Use provided userId, session userId, or create a test user
+        let targetUserId = providedUserId || req.session.userId;
+        if (!targetUserId) {
+            // Create a test user if none exists
+            const testId = `test-ws-${randomUUID()}`;
+            const [newUser] = await db.insert(users).values({
+                email: `${testId}@test.local`,
+                githubId: testId,
+                githubUsername: 'workspace-test-user',
+                avatarUrl: null,
+                plan: 'free',
+            }).returning();
+            targetUserId = newUser.id;
+        }
+        const targetRepoFullName = repoFullName || `test-org/test-repo-${Date.now()}`;
+        // Create workspace
+        const [workspace] = await db.insert(workspaces).values({
+            userId: targetUserId,
+            name: name || `Test Workspace ${Date.now()}`,
+            status: 'running',
+            publicUrl: 'http://localhost:3889',
+            computeProvider: 'docker',
+            computeId: `test-${randomUUID().slice(0, 8)}`,
+            config: {
+                providers: ['anthropic'],
+                repositories: [targetRepoFullName],
+                supervisorEnabled: true,
+                maxAgents: 10,
+            },
+        }).returning();
+        // Create a linked repository for workspace lookup via repoFullName
+        const [repo] = await db.insert(repositories).values({
+            userId: targetUserId,
+            workspaceId: workspace.id,
+            githubId: Math.floor(Math.random() * 1000000),
+            githubFullName: targetRepoFullName,
+            isPrivate: false,
+            defaultBranch: 'main',
+            syncStatus: 'synced',
+            nangoConnectionId: `mock-${randomUUID().slice(0, 8)}`,
+            lastSyncedAt: new Date(),
+        }).returning();
+        res.json({
+            workspaceId: workspace.id,
+            name: workspace.name,
+            repoFullName: repo.githubFullName,
+            repoId: repo.id,
+            userId: targetUserId,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test workspace:', error);
+        res.status(500).json({ error: 'Failed to create test workspace' });
+    }
+});
+/**
+ * POST /api/test/create-daemon-with-workspace
+ * Creates a test daemon linked to a workspace
+ */
+testHelpersRouter.post('/create-daemon-with-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, machineId, workspaceId, userId: providedUserId } = req.body;
+        if (!name) {
+            return res.status(400).json({ error: 'name is required' });
+        }
+        const db = getDb();
+        // Get or create test user
+        let targetUserId = providedUserId;
+        if (!targetUserId) {
+            const existingUsers = await db.select().from(users).limit(1);
+            if (existingUsers.length > 0) {
+                targetUserId = existingUsers[0].id;
+            }
+            else {
+                const testId = `test-daemon-${randomUUID()}`;
+                const [newUser] = await db.insert(users).values({
+                    email: `${testId}@test.local`,
+                    githubId: testId,
+                    githubUsername: 'daemon-test-user',
+                    avatarUrl: null,
+                    plan: 'free',
+                }).returning();
+                targetUserId = newUser.id;
+            }
+        }
+        // Generate API key
+        const apiKey = `ar_live_${randomBytes(32).toString('hex')}`;
+        const apiKeyHash = createHash('sha256').update(apiKey).digest('hex');
+        // Create daemon with optional workspace link
+        const [daemon] = await db.insert(linkedDaemons).values({
+            userId: targetUserId,
+            workspaceId: workspaceId || null,
+            name,
+            machineId: machineId || randomUUID(),
+            apiKeyHash,
+            status: 'online',
+            metadata: {
+                hostname: 'test-host',
+                platform: 'linux',
+                version: '1.0.0-test',
+            },
+        }).returning();
+        res.json({
+            daemonId: daemon.id,
+            apiKey,
+            name: daemon.name,
+            machineId: daemon.machineId,
+            workspaceId: daemon.workspaceId,
+            userId: targetUserId,
+        });
+    }
+    catch (error) {
+        console.error('Error creating test daemon:', error);
+        res.status(500).json({ error: 'Failed to create test daemon' });
+    }
+});
+/**
+ * DELETE /api/test/cleanup
+ * Cleans up test data
+ */
+testHelpersRouter.delete('/cleanup', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const _db = getDb();
+        // Delete test data (users with test- prefix in githubId)
+        // Note: This cascades to linked daemons due to FK constraints
+        res.json({ success: true, message: 'Test data cleaned up' });
+    }
+    catch (error) {
+        console.error('Error cleaning up test data:', error);
+        res.status(500).json({ error: 'Failed to cleanup test data' });
+    }
+});
+/**
+ * GET /api/test/status
+ * Returns test mode status
+ */
+testHelpersRouter.get('/status', (req, res) => {
+    res.json({
+        testMode: isTestMode,
+        nodeEnv: process.env.NODE_ENV,
+        timestamp: new Date().toISOString(),
+    });
+});
+/**
+ * POST /api/test/create-mock-workspace
+ * Creates a mock workspace pointing to a local dashboard server
+ *
+ * Use this to test the cloud flow locally without real provisioning.
+ * The workspace will have publicUrl pointing to localhost:3889.
+ */
+testHelpersRouter.post('/create-mock-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { name, publicUrl } = req.body;
+        const userId = req.session.userId;
+        if (!userId) {
+            return res.status(401).json({ error: 'Must be logged in. Use /api/test/create-user first or log in via OAuth.' });
+        }
+        const db = getDb();
+        // Create a mock workspace with local publicUrl
+        const [workspace] = await db.insert(workspaces).values({
+            userId,
+            name: name || 'Local Test Workspace',
+            status: 'running',
+            publicUrl: publicUrl || 'http://localhost:3889',
+            computeProvider: 'docker',
+            computeId: `mock-${randomUUID().slice(0, 8)}`,
+            config: {
+                providers: ['anthropic'],
+                repositories: [],
+                supervisorEnabled: true,
+                maxAgents: 10,
+            },
+        }).returning();
+        res.json({
+            workspaceId: workspace.id,
+            name: workspace.name,
+            status: workspace.status,
+            publicUrl: workspace.publicUrl,
+            message: 'Mock workspace created. Start agent-relay locally and navigate to /app.',
+        });
+    }
+    catch (error) {
+        console.error('Error creating mock workspace:', error);
+        res.status(500).json({ error: 'Failed to create mock workspace' });
+    }
+});
+/**
+ * POST /api/test/create-mock-repo
+ * Creates a mock repository for the current user
+ *
+ * Use this to test the cloud flow without connecting real GitHub repos.
+ */
+testHelpersRouter.post('/create-mock-repo', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { fullName, isPrivate } = req.body;
+        const userId = req.session.userId;
+        if (!userId) {
+            return res.status(401).json({ error: 'Must be logged in. Use /api/test/create-user first or log in via OAuth.' });
+        }
+        if (!fullName) {
+            return res.status(400).json({ error: 'fullName is required (e.g., "owner/repo")' });
+        }
+        const db = getDb();
+        // Create a mock repository
+        const [repo] = await db.insert(repositories).values({
+            userId,
+            githubId: Math.floor(Math.random() * 1000000),
+            githubFullName: fullName,
+            isPrivate: isPrivate ?? false,
+            defaultBranch: 'main',
+            syncStatus: 'synced',
+            nangoConnectionId: `mock-connection-${randomUUID().slice(0, 8)}`,
+            lastSyncedAt: new Date(),
+        }).returning();
+        res.json({
+            repoId: repo.id,
+            fullName: repo.githubFullName,
+            isPrivate: repo.isPrivate,
+            message: 'Mock repository created.',
+        });
+    }
+    catch (error) {
+        console.error('Error creating mock repo:', error);
+        res.status(500).json({ error: 'Failed to create mock repo' });
+    }
+});
+/**
+ * GET /api/test/auto-login
+ * Browser-friendly auto-login - visit this URL to login and redirect
+ * Usage: /api/test/auto-login?redirect=/providers/setup/claude?workspace=xxx
+ */
+testHelpersRouter.get('/auto-login', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const db = getDb();
+        const redirect = req.query.redirect || '/app';
+        // Find or create test user
+        let user;
+        const existingUsers = await db.select().from(users).limit(1);
+        if (existingUsers.length > 0) {
+            user = existingUsers[0];
+        }
+        else {
+            const testId = `test-${randomUUID()}`;
+            const [newUser] = await db.insert(users).values({
+                email: `${testId}@test.local`,
+                githubId: testId,
+                githubUsername: 'test-user',
+                avatarUrl: null,
+                plan: 'free',
+            }).returning();
+            user = newUser;
+        }
+        // Set session and CSRF token
+        req.session.userId = user.id;
+        req.session.csrfToken = randomUUID();
+        // Redirect to requested page
+        res.redirect(redirect);
+    }
+    catch (error) {
+        console.error('Error in auto-login:', error);
+        res.status(500).json({ error: 'Failed to auto-login' });
+    }
+});
+/**
+ * POST /api/test/login-as
+ * Quick login for testing - creates session for existing or new test user
+ */
+testHelpersRouter.post('/login-as', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { username } = req.body;
+        const db = getDb();
+        // Find or create user
+        let user;
+        const existingUsers = await db.select().from(users).limit(1);
+        if (existingUsers.length > 0 && !username) {
+            user = existingUsers[0];
+        }
+        else {
+            const testId = `test-${randomUUID()}`;
+            const [newUser] = await db.insert(users).values({
+                email: `${username || testId}@test.local`,
+                githubId: testId,
+                githubUsername: username || 'test-user',
+                avatarUrl: null,
+                plan: 'free',
+            }).returning();
+            user = newUser;
+        }
+        // Set session
+        req.session.userId = user.id;
+        res.json({
+            success: true,
+            userId: user.id,
+            username: user.githubUsername,
+            message: 'Logged in. You can now access /app and other authenticated routes.',
+        });
+    }
+    catch (error) {
+        console.error('Error in login-as:', error);
+        res.status(500).json({ error: 'Failed to login' });
+    }
+});
+/**
+ * GET /api/test/setup-local-cloud
+ * One-shot setup: creates user, mock repo, and mock workspace
+ *
+ * After calling this, start agent-relay locally and go to /app
+ */
+testHelpersRouter.post('/setup-local-cloud', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    try {
+        const { repoName, workspaceName } = req.body;
+        const db = getDb();
+        // 1. Create or get test user
+        const testId = `test-${randomUUID().slice(0, 8)}`;
+        const [user] = await db.insert(users).values({
+            email: `${testId}@test.local`,
+            githubId: testId,
+            githubUsername: 'local-tester',
+            avatarUrl: null,
+            plan: 'free',
+        }).returning();
+        // Set session
+        req.session.userId = user.id;
+        // 2. Create mock repository
+        const [repo] = await db.insert(repositories).values({
+            userId: user.id,
+            githubId: Math.floor(Math.random() * 1000000),
+            githubFullName: repoName || 'test-org/test-repo',
+            isPrivate: false,
+            defaultBranch: 'main',
+            syncStatus: 'synced',
+            nangoConnectionId: `mock-${randomUUID().slice(0, 8)}`,
+            lastSyncedAt: new Date(),
+        }).returning();
+        // 3. Create mock workspace pointing to local dashboard
+        const [workspace] = await db.insert(workspaces).values({
+            userId: user.id,
+            name: workspaceName || 'Local Development',
+            status: 'running',
+            publicUrl: 'http://localhost:3889',
+            computeProvider: 'docker',
+            computeId: `mock-${randomUUID().slice(0, 8)}`,
+            config: {
+                providers: ['anthropic'],
+                repositories: [repo.githubFullName],
+                supervisorEnabled: true,
+                maxAgents: 10,
+            },
+        }).returning();
+        res.json({
+            success: true,
+            user: {
+                id: user.id,
+                username: user.githubUsername,
+            },
+            repo: {
+                id: repo.id,
+                fullName: repo.githubFullName,
+            },
+            workspace: {
+                id: workspace.id,
+                name: workspace.name,
+                publicUrl: workspace.publicUrl,
+            },
+            instructions: [
+                '1. Start agent-relay daemon: npm run dev (or agent-relay up)',
+                '2. Go to http://localhost:4567/app',
+                '3. The app should auto-connect to the local workspace',
+                '4. The WebSocket will connect to ws://localhost:3889/ws',
+            ],
+        });
+    }
+    catch (error) {
+        console.error('Error in setup-local-cloud:', error);
+        res.status(500).json({ error: 'Failed to setup local cloud' });
+    }
+});
+/**
+ * POST /api/test/provision-real-workspace
+ * Provision a REAL Docker container using your Nango GitHub App connection.
+ *
+ * This tests the full flow including:
+ * - Fetching GitHub App token from Nango
+ * - Spinning up a Docker container
+ * - Cloning your actual repositories
+ *
+ * Prerequisites:
+ * - Must be logged in (via real OAuth or /api/test/login-as)
+ * - Must have connected repos via /connect-repos (real Nango GitHub App OAuth)
+ * - Docker must be running locally
+ * - COMPUTE_PROVIDER must be 'docker' (default for dev)
+ */
+testHelpersRouter.post('/provision-real-workspace', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    const userId = req.session.userId;
+    if (!userId) {
+        return res.status(401).json({
+            error: 'Must be logged in. Use real OAuth or /api/test/login-as first.',
+        });
+    }
+    try {
+        const { name, repositoryFullName, providers, githubToken } = req.body;
+        // Get user's connected repositories
+        const userRepos = await db.repositories.findByUserId(userId);
+        const reposWithNango = userRepos.filter(r => r.nangoConnectionId);
+        if (reposWithNango.length === 0) {
+            return res.status(400).json({
+                error: 'No repositories with Nango connection found. Complete /connect-repos first with real GitHub OAuth.',
+                hint: 'Go to http://localhost:4567/connect-repos and connect your GitHub App, or pass githubToken directly',
+            });
+        }
+        // Determine which repo to use
+        let targetRepo = reposWithNango[0];
+        if (repositoryFullName) {
+            const found = reposWithNango.find(r => r.githubFullName === repositoryFullName);
+            if (!found) {
+                return res.status(400).json({
+                    error: `Repository ${repositoryFullName} not found or not connected via Nango`,
+                    availableRepos: reposWithNango.map(r => r.githubFullName),
+                });
+            }
+            targetRepo = found;
+        }
+        // Use the real provisioner (Docker in dev mode)
+        const provisioner = getProvisioner();
+        const result = await provisioner.provision({
+            userId,
+            name: name || `Test Workspace - ${targetRepo.githubFullName}`,
+            providers: providers || ['anthropic'], // Default to anthropic if not specified
+            repositories: [targetRepo.githubFullName],
+            supervisorEnabled: true,
+            maxAgents: 10,
+            // Allow passing GitHub token directly for local testing
+            githubToken: githubToken || undefined,
+        });
+        if (result.status === 'error') {
+            return res.status(500).json({
+                error: 'Provisioning failed',
+                details: result.error,
+            });
+        }
+        res.json({
+            success: true,
+            workspace: {
+                id: result.workspaceId,
+                status: result.status,
+                publicUrl: result.publicUrl,
+            },
+            repository: targetRepo.githubFullName,
+            instructions: [
+                `1. Workspace is running at ${result.publicUrl}`,
+                `2. Repository ${targetRepo.githubFullName} should be cloned`,
+                `3. Go to http://localhost:4567/app to connect`,
+                `4. Check container: docker logs ar-${result.workspaceId.substring(0, 8)}`,
+                `5. Verify clone: docker exec ar-${result.workspaceId.substring(0, 8)} ls /workspace/repos`,
+            ],
+        });
+    }
+    catch (error) {
+        console.error('Error provisioning real workspace:', error);
+        res.status(500).json({
+            error: 'Failed to provision workspace',
+            details: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * GET /api/test/my-repos
+ * List current user's connected repositories (for debugging)
+ */
+testHelpersRouter.get('/my-repos', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    const userId = req.session.userId;
+    if (!userId) {
+        return res.status(401).json({ error: 'Not logged in' });
+    }
+    try {
+        const repos = await db.repositories.findByUserId(userId);
+        res.json({
+            userId,
+            repositories: repos.map(r => ({
+                id: r.id,
+                fullName: r.githubFullName,
+                isPrivate: r.isPrivate,
+                hasNangoConnection: !!r.nangoConnectionId,
+                nangoConnectionId: r.nangoConnectionId, // For debugging
+                syncStatus: r.syncStatus,
+            })),
+        });
+    }
+    catch (error) {
+        console.error('Error fetching repos:', error);
+        res.status(500).json({ error: 'Failed to fetch repositories' });
+    }
+});
+/**
+ * GET /api/test/my-workspaces
+ * List current user's workspaces (for debugging)
+ */
+testHelpersRouter.get('/my-workspaces', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    const userId = req.session.userId;
+    if (!userId) {
+        return res.status(401).json({ error: 'Not logged in' });
+    }
+    try {
+        const userWorkspaces = await db.workspaces.findByUserId(userId);
+        res.json({
+            userId,
+            workspaces: userWorkspaces.map(w => ({
+                id: w.id,
+                name: w.name,
+                status: w.status,
+                publicUrl: w.publicUrl,
+                computeProvider: w.computeProvider,
+                computeId: w.computeId,
+                config: w.config,
+            })),
+        });
+    }
+    catch (error) {
+        console.error('Error fetching workspaces:', error);
+        res.status(500).json({ error: 'Failed to fetch workspaces' });
+    }
+});
+/**
+ * GET /api/test/nango-token
+ * Test fetching GitHub App token from Nango (for debugging)
+ */
+testHelpersRouter.get('/nango-token', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    const userId = req.session.userId;
+    if (!userId) {
+        return res.status(401).json({ error: 'Not logged in' });
+    }
+    try {
+        const repos = await db.repositories.findByUserId(userId);
+        const repoWithConnection = repos.find(r => r.nangoConnectionId);
+        if (!repoWithConnection?.nangoConnectionId) {
+            return res.status(400).json({
+                error: 'No Nango connection found',
+                repos: repos.map(r => ({ fullName: r.githubFullName, nangoConnectionId: r.nangoConnectionId })),
+            });
+        }
+        console.log('[test] Fetching token for connection:', repoWithConnection.nangoConnectionId);
+        const token = await nangoService.getGithubAppToken(repoWithConnection.nangoConnectionId);
+        res.json({
+            success: true,
+            connectionId: repoWithConnection.nangoConnectionId,
+            tokenLength: token.length,
+            tokenPrefix: token.substring(0, 10) + '...',
+        });
+    }
+    catch (error) {
+        console.error('[test] Nango token fetch error:', error);
+        res.status(500).json({
+            error: 'Failed to fetch token',
+            details: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+});
+/**
+ * DELETE /api/test/workspace/:id
+ * Delete/deprovision a workspace (for cleanup)
+ */
+testHelpersRouter.delete('/workspace/:id', async (req, res) => {
+    if (!isTestMode) {
+        return res.status(403).json({ error: 'Test endpoints disabled in production' });
+    }
+    const userId = req.session.userId;
+    if (!userId) {
+        return res.status(401).json({ error: 'Not logged in' });
+    }
+    try {
+        const id = req.params.id;
+        const workspace = await db.workspaces.findById(id);
+        if (!workspace) {
+            return res.status(404).json({ error: 'Workspace not found' });
+        }
+        if (workspace.userId !== userId) {
+            return res.status(403).json({ error: 'Not your workspace' });
+        }
+        const provisioner = getProvisioner();
+        await provisioner.deprovision(id);
+        res.json({
+            success: true,
+            message: `Workspace ${id} deleted`,
+        });
+    }
+    catch (error) {
+        console.error('Error deleting workspace:', error);
+        res.status(500).json({ error: 'Failed to delete workspace' });
+    }
+});
+//# sourceMappingURL=test-helpers.js.map