deepdebug-local-agent 1.0.18 → 1.0.20

package/src/vercel-proxy.js

@@ -0,0 +1,226 @@
+/**
+ * vercel-proxy.js
+ *
+ * Proxy module for Vercel API calls from the Local Agent.
+ * The Gateway (Cloud Run) cannot reach api.vercel.com directly due to egress rules.
+ * All Vercel API calls are routed through the Agent which has unrestricted outbound access.
+ *
+ * Endpoints registered in server.js:
+ *   POST /vercel/projects/ensure   - Create project if not exists, return projectId
+ *   POST /vercel/deploy            - Trigger a deployment, return { deploymentId, previewUrl }
+ *   GET  /vercel/deploy/:id/status - Poll deployment status
+ *   GET  /vercel/projects          - List all projects
+ *
+ * All endpoints require { token } in body or query param.
+ */
+
+const VERCEL_API = "https://api.vercel.com";
+
+/**
+ * Make an authenticated request to the Vercel API.
+ */
+async function vercelRequest(method, path, token, body = null) {
+    const opts = {
+        method,
+        headers: {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json"
+        }
+    };
+    if (body) opts.body = JSON.stringify(body);
+
+    const res = await fetch(`${VERCEL_API}${path}`, opts);
+    const text = await res.text();
+
+    let data;
+    try {
+        data = JSON.parse(text);
+    } catch {
+        data = { raw: text };
+    }
+
+    if (!res.ok) {
+        const errMsg = data?.error?.message || data?.message || text;
+        throw new Error(`Vercel API ${method} ${path} -> ${res.status}: ${errMsg}`);
+    }
+
+    return data;
+}
+
+/**
+ * Ensure a Vercel project exists.
+ * Creates it if missing, returns the project ID.
+ */
+async function ensureProject(token, projectName, repoOwner, repoName, framework) {
+    // Try to get existing project
+    try {
+        const existing = await vercelRequest("GET", `/v9/projects/${projectName}`, token);
+        console.log(`[Vercel] Project exists: ${projectName} (${existing.id})`);
+        return existing.id;
+    } catch (err) {
+        if (!err.message.includes("404")) throw err;
+    }
+
+    // Create project
+    console.log(`[Vercel] Creating project: ${projectName}`);
+    const body = {
+        name: projectName,
+        gitRepository: {
+            type: "github",
+            repo: `${repoOwner}/${repoName}`
+        }
+    };
+    if (framework) body.framework = framework;
+
+    const created = await vercelRequest("POST", "/v9/projects", token, body);
+    console.log(`[Vercel] Project created: ${projectName} (${created.id})`);
+    return created.id;
+}
+
+/**
+ * Trigger a deployment for a project.
+ */
+async function triggerDeploy(token, projectId, projectName, repoId, branch) {
+    console.log(`[Vercel] Triggering deploy: project=${projectName} branch=${branch}`);
+
+    const body = {
+        name: projectName,
+        target: "preview",
+        gitSource: {
+            type: "github",
+            repoId: String(repoId),
+            ref: branch || "main"
+        }
+    };
+
+    const deployment = await vercelRequest("POST", "/v13/deployments", token, body);
+
+    const previewUrl = `https://${deployment.url}`;
+    console.log(`[Vercel] Deploy triggered: ${deployment.id} -> ${previewUrl}`);
+
+    return {
+        deploymentId: deployment.id,
+        previewUrl,
+        status: deployment.readyState || "INITIALIZING",
+        projectId,
+        projectName
+    };
+}
+
+/**
+ * Get deployment status.
+ */
+async function getDeployStatus(token, deploymentId) {
+    const d = await vercelRequest("GET", `/v13/deployments/${deploymentId}`, token);
+    return {
+        deploymentId: d.id,
+        status: d.readyState,
+        previewUrl: `https://${d.url}`,
+        errorMessage: d.errorMessage || null,
+        ready: d.readyState === "READY",
+        failed: d.readyState === "ERROR" || d.readyState === "CANCELED"
+    };
+}
+
+/**
+ * List all projects.
+ */
+async function listProjects(token) {
+    const data = await vercelRequest("GET", "/v9/projects?limit=20", token);
+    return (data.projects || []).map(p => ({
+        id: p.id,
+        name: p.name,
+        framework: p.framework,
+        updatedAt: p.updatedAt,
+        latestDeploy: p.latestDeployments?.[0]?.url
+            ? `https://${p.latestDeployments[0].url}`
+            : null
+    }));
+}
+
+/**
+ * Register Vercel proxy routes on the Express app.
+ *
+ * @param {import('express').Application} app
+ */
+export function registerVercelRoutes(app) {
+
+    /**
+     * POST /vercel/projects/ensure
+     * Body: { token, projectName, repoOwner, repoName, framework? }
+     * Response: { ok, projectId }
+     */
+    app.post("/vercel/projects/ensure", async (req, res) => {
+        const { token, projectName, repoOwner, repoName, framework } = req.body || {};
+        if (!token || !projectName || !repoOwner || !repoName) {
+            return res.status(400).json({ ok: false, error: "token, projectName, repoOwner, repoName required" });
+        }
+        try {
+            const projectId = await ensureProject(token, projectName, repoOwner, repoName, framework);
+            return res.json({ ok: true, projectId, projectName });
+        } catch (err) {
+            console.error(`[Vercel] ensureProject failed: ${err.message}`);
+            return res.status(500).json({ ok: false, error: err.message });
+        }
+    });
+
+    /**
+     * POST /vercel/deploy
+     * Body: { token, projectId, projectName, repoOwner, repoName, branch? }
+     * Note: repoId is fetched automatically from GitHub API if not provided.
+     * Response: { ok, deploymentId, previewUrl, status }
+     */
+    app.post("/vercel/deploy", async (req, res) => {
+        const { token, projectId, projectName, repoOwner, repoName, branch } = req.body || {};
+        if (!token || !projectId || !projectName || !repoOwner || !repoName) {
+            return res.status(400).json({ ok: false, error: "token, projectId, projectName, repoOwner, repoName required" });
+        }
+        try {
+            // Fetch repoId from GitHub API
+            const ghRes = await fetch(`https://api.github.com/repos/${repoOwner}/${repoName}`);
+            if (!ghRes.ok) throw new Error(`GitHub repo not found: ${repoOwner}/${repoName}`);
+            const ghData = await ghRes.json();
+            const repoId = ghData.id;
+            const result = await triggerDeploy(token, projectId, projectName, repoId, branch);
+            return res.json({ ok: true, ...result });
+        } catch (err) {
+            console.error(`[Vercel] deploy failed: ${err.message}`);
+            return res.status(500).json({ ok: false, error: err.message });
+        }
+    });
+
+    /**
+     * GET /vercel/deploy/:deploymentId/status?token=xxx
+     * Response: { ok, deploymentId, status, previewUrl, ready, failed }
+     */
+    app.get("/vercel/deploy/:deploymentId/status", async (req, res) => {
+        const { deploymentId } = req.params;
+        const token = req.query.token;
+        if (!token) return res.status(400).json({ ok: false, error: "token query param required" });
+        try {
+            const result = await getDeployStatus(token, deploymentId);
+            return res.json({ ok: true, ...result });
+        } catch (err) {
+            console.error(`[Vercel] status check failed: ${err.message}`);
+            return res.status(500).json({ ok: false, error: err.message });
+        }
+    });
+
+    /**
+     * GET /vercel/projects?token=xxx
+     * Response: { ok, projects[] }
+     */
+    app.get("/vercel/projects", async (req, res) => {
+        const token = req.query.token;
+        if (!token) return res.status(400).json({ ok: false, error: "token query param required" });
+        try {
+            const projects = await listProjects(token);
+            return res.json({ ok: true, projects });
+        } catch (err) {
+            console.error(`[Vercel] listProjects failed: ${err.message}`);
+            return res.status(500).json({ ok: false, error: err.message });
+        }
+    });
+
+    console.log("[Vercel] Proxy routes registered: /vercel/projects/ensure, /vercel/deploy, /vercel/deploy/:id/status, /vercel/projects");
+}

package/tunnel-manager.js

@@ -0,0 +1,70 @@
+const { spawn } = require('child_process');
+const activeTunnels = new Map();
+
+async function startTunnel(sessionId, port) {
+    // If tunnel already exists for this session, return existing URL
+    const existing = activeTunnels.get(sessionId);
+    if (existing && existing.url) {
+        return existing.url;
+    }
+
+    return new Promise((resolve, reject) => {
+        const proc = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+
+        let tunnelUrl = null;
+
+        const timeout = setTimeout(() => {
+            if (!tunnelUrl) {
+                proc.kill();
+                reject(new Error('Tunnel startup timeout after 30s'));
+            }
+        }, 30000);
+
+        const onData = (data) => {
+            const match = data.toString().match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+            if (match && !tunnelUrl) {
+                tunnelUrl = match[0];
+                clearTimeout(timeout);
+                activeTunnels.set(sessionId, { process: proc, url: tunnelUrl, port });
+                console.log(`[Tunnel] Ready: ${tunnelUrl} (session: ${sessionId})`);
+                resolve(tunnelUrl);
+            }
+        };
+
+        proc.stdout.on('data', onData);
+        proc.stderr.on('data', onData);
+
+        proc.on('exit', (code) => {
+            activeTunnels.delete(sessionId);
+            console.log(`[Tunnel] Process exited for session ${sessionId} (code: ${code})`);
+        });
+
+        proc.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}
+
+function stopTunnel(sessionId) {
+    const tunnel = activeTunnels.get(sessionId);
+    if (tunnel) {
+        tunnel.process.kill('SIGTERM');
+        activeTunnels.delete(sessionId);
+        console.log(`[Tunnel] Stopped: ${sessionId}`);
+        return true;
+    }
+    return false;
+}
+
+function getTunnelInfo(sessionId) {
+    return activeTunnels.get(sessionId) || null;
+}
+
+function getActiveTunnelCount() {
+    return activeTunnels.size;
+}
+
+module.exports = { startTunnel, stopTunnel, getTunnelInfo, getActiveTunnelCount };