@debugg-ai/debugg-ai-mcp 1.0.22 → 1.0.25

package/dist/handlers/liveSessionHandlers.js

@@ -76,12 +76,12 @@ export async function startLiveSessionHandler(input, context, progressCallback)
         if (!session) {
             throw new Error('Failed to start browser session: No session returned');
         }
-        // If we need a tunnel, create it now using the tunnelKey from the backend
+        // If we need a tunnel, create it now using the tunnel key from the session response
         if (isLocalhost && tunnelId) {
-            const tunnelAuthToken = session.tunnelKey;
-            if (!tunnelAuthToken) {
-                throw new Error('No tunnel key provided by backend - tunnels not available for localhost URLs');
+            if (!session.tunnelKey) {
+                throw new Error('Backend did not return a tunnel key for localhost session');
             }
+            const tunnelAuthToken = session.tunnelKey;
             logger.info(`Creating tunnel with backend-provided key for ${input.url} -> ${sessionUrl}`);
             // Create the tunnel using the original localhost URL and the generated tunnel ID
             const port = extractLocalhostPort(input.url);

package/dist/handlers/testPageChangesHandler.js

@@ -35,44 +35,13 @@ export async function testPageChangesHandler(input, context, progressCallback) {
     const client = new DebuggAIServerClient(config.api.key);
     await client.init();
     let tunnelId;
+    let ngrokKeyId;
     try {
         const targetUrlRaw = resolveTargetUrl(input);
-        let targetUrl = targetUrlRaw;
-        // --- Localhost tunneling ---
-        if (isLocalhostUrl(targetUrlRaw)) {
-            if (progressCallback) {
-                await progressCallback({ progress: 1, total: 10, message: 'Creating secure tunnel for localhost...' });
-            }
-            const port = extractLocalhostPort(targetUrlRaw);
-            if (!port) {
-                throw new Error(`Could not extract port from localhost URL: ${targetUrlRaw}`);
-            }
-            const { v4: uuidv4 } = await import('uuid');
-            tunnelId = uuidv4();
-            const tunnelPublicUrl = `https://${tunnelId}.ngrok.debugg.ai`;
-            // Start a minimal browser session to obtain the ngrok auth token
-            const session = await client.browserSessions.startSession({
-                url: tunnelPublicUrl,
-                originalUrl: targetUrlRaw,
-                localPort: port,
-                sessionName: `Tunnel provisioning for ${targetUrlRaw}`,
-                monitorConsole: false,
-                monitorNetwork: false,
-                takeScreenshots: false,
-                isLocalhost: true,
-                tunnelId,
-            });
-            const tunnelAuthToken = session.tunnelKey;
-            if (!tunnelAuthToken) {
-                throw new Error('Browser sessions service did not return a tunnel auth token');
-            }
-            const tunnelResult = await tunnelManager.processUrl(targetUrlRaw, tunnelAuthToken, tunnelId);
-            targetUrl = tunnelResult.url;
-            logger.info(`Tunnel ready: ${targetUrl}`);
-        }
+        const isLocalhost = isLocalhostUrl(targetUrlRaw);
         // --- Find workflow template ---
         if (progressCallback) {
-            await progressCallback({ progress: 2, total: 10, message: 'Locating evaluation workflow template...' });
+            await progressCallback({ progress: 1, total: 10, message: 'Locating evaluation workflow template...' });
         }
         if (!cachedTemplateUuid) {
             const template = await client.workflows.findEvaluationTemplate();
@@ -85,15 +54,33 @@ export async function testPageChangesHandler(input, context, progressCallback) {
         }
         // --- Build context data ---
         const contextData = {
-            targetUrl: targetUrl,
+            targetUrl: targetUrlRaw,
             question: input.description,
         };
         // --- Execute ---
         if (progressCallback) {
-            await progressCallback({ progress: 3, total: 10, message: 'Queuing workflow execution...' });
+            await progressCallback({ progress: 2, total: 10, message: 'Queuing workflow execution...' });
         }
-        const executionUuid = await client.workflows.executeWorkflow(cachedTemplateUuid, contextData);
+        const executeResponse = await client.workflows.executeWorkflow(cachedTemplateUuid, contextData);
+        const executionUuid = executeResponse.executionUuid;
+        ngrokKeyId = executeResponse.ngrokKeyId ?? undefined;
         logger.info(`Execution queued: ${executionUuid}`);
+        // --- Localhost tunneling (after execute, using tunnel_key + executionUuid as subdomain) ---
+        if (isLocalhost) {
+            if (progressCallback) {
+                await progressCallback({ progress: 3, total: 10, message: 'Creating secure tunnel for localhost...' });
+            }
+            const port = extractLocalhostPort(targetUrlRaw);
+            if (!port) {
+                throw new Error(`Could not extract port from localhost URL: ${targetUrlRaw}`);
+            }
+            if (!executeResponse.tunnelKey) {
+                throw new Error('Backend did not return a tunnel key for localhost execution');
+            }
+            tunnelId = executionUuid;
+            const tunnelResult = await tunnelManager.processUrl(targetUrlRaw, executeResponse.tunnelKey, tunnelId);
+            logger.info(`Tunnel ready: ${tunnelResult.url}`);
+        }
         // --- Poll ---
         let lastSteps = 0;
         const finalExecution = await client.workflows.pollExecution(executionUuid, async (exec) => {
@@ -120,7 +107,7 @@ export async function testPageChangesHandler(input, context, progressCallback) {
             success: finalExecution.state?.success ?? false,
             status: finalExecution.status,
             stepsTaken: finalExecution.state?.stepsTaken ?? surferNode?.outputData?.stepsTaken ?? 0,
-            targetUrl,
+            targetUrl: targetUrlRaw,
             executionId: executionUuid,
             durationMs: finalExecution.durationMs ?? duration,
         };
@@ -157,6 +144,10 @@ export async function testPageChangesHandler(input, context, progressCallback) {
         throw handleExternalServiceError(error, 'DebuggAI', 'test execution');
     }
     finally {
+        // Revoke the short-lived ngrok key
+        if (ngrokKeyId) {
+            client.revokeNgrokKey(ngrokKeyId).catch(err => logger.warn(`Failed to revoke ngrok key ${ngrokKeyId}: ${err}`));
+        }
         // Clean up tunnel if we created one
         if (tunnelId) {
             tunnelManager.stopTunnel(tunnelId).catch(err => logger.warn(`Failed to stop tunnel ${tunnelId}: ${err}`));

package/dist/services/index.js

@@ -50,6 +50,15 @@ export class DebuggAIServerClient {
         this.browserSessions = createBrowserSessionsService(this.tx);
         this.workflows = createWorkflowsService(this.tx);
     }
+    /**
+     * Revoke an ngrok API key by its key ID.
+     * Call this after workflow execution completes to clean up the short-lived key.
+     */
+    async revokeNgrokKey(ngrokKeyId) {
+        if (!this.tx)
+            throw new Error('Client not initialized — call init() first');
+        await this.tx.post('api/v1/ngrok/revoke/', { ngrokKeyId });
+    }
 }
 /**
  * Create and initialize a service client

package/dist/services/workflows.js

@@ -13,12 +13,23 @@ export const createWorkflowsService = (tx) => {
             const evalTemplate = templates.find(t => t.name.toLowerCase().includes('app evaluation'));
             return evalTemplate ?? templates[0] ?? null;
         },
-        async executeWorkflow(workflowUuid, contextData) {
-            const response = await tx.post(`api/v1/workflows/${workflowUuid}/execute/`, { contextData });
+        async executeWorkflow(workflowUuid, contextData, env) {
+            const body = { contextData };
+            if (env && Object.keys(env).length > 0) {
+                body.env = env;
+            }
+            const response = await tx.post(`api/v1/workflows/${workflowUuid}/execute/`, body);
             if (!response?.resourceUuid) {
                 throw new Error('Workflow execution failed: no execution UUID returned');
             }
-            return response.resourceUuid;
+            return {
+                executionUuid: response.resourceUuid,
+                tunnelKey: response.tunnelKey ?? null,
+                ngrokKeyId: response.ngrokKeyId ?? null,
+                ngrokExpiresAt: response.ngrokExpiresAt ?? null,
+                resolvedEnvironmentId: response.resolvedEnvironmentId ?? null,
+                resolvedCredentialId: response.resolvedCredentialId ?? null,
+            };
         },
         async getExecution(executionUuid) {
             const response = await tx.get(`api/v1/workflows/executions/${executionUuid}/`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@debugg-ai/debugg-ai-mcp",
-  "version": "1.0.22",
+  "version": "1.0.25",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {

package/dist/e2e-agents/e2eRunner.js

@@ -1,145 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-let ngrokModule = null;
-async function getNgrok() {
-    if (!ngrokModule) {
-        try {
-            ngrokModule = require('ngrok');
-        }
-        catch (error) {
-            throw new Error(`Failed to load ngrok module: ${error}`);
-        }
-    }
-    return ngrokModule;
-}
-async function startTunnel(authToken, localPort, domain) {
-    try {
-        const ngrok = await getNgrok();
-        if (process.env.DOCKER_CONTAINER === "true") {
-            const url = await ngrok.connect({ proto: 'http', addr: `host.docker.internal:${localPort}`, hostname: domain, authtoken: authToken });
-            return url;
-        }
-        else {
-            const url = await ngrok.connect({ proto: 'http', addr: localPort, hostname: domain, authtoken: authToken });
-            return url;
-        }
-    }
-    catch (err) {
-        console.error('Error starting ngrok tunnel:', err);
-        throw err;
-    }
-}
-async function stopTunnel(url) {
-    try {
-        const ngrok = await getNgrok();
-        if (url) {
-            await ngrok.disconnect(url);
-        }
-        else {
-            await ngrok.disconnect();
-        }
-    }
-    catch (err) {
-        console.error('Error stopping ngrok tunnel:', err);
-    }
-}
-const POLL_INTERVAL_MS = 1500;
-const TIMEOUT_MS = 900_000; // 15 minutes
-export class E2eTestRunner {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    async setup() {
-        await this.configureNgrok();
-    }
-    async configureNgrok() {
-        // ngrok binary is downloaded automatically by the ngrok package
-    }
-    async startTunnel(authToken, port, url) {
-        await startTunnel(authToken, port, url);
-        console.error(`Tunnel started at: ${url}`);
-        return url;
-    }
-    /**
-     * Create a new E2E test and run it.
-     */
-    async createNewE2eTest(testPort, testDescription, repoName, branchName, repoPath, filePath) {
-        console.error(`Creating new E2E test with description: ${testDescription}`);
-        const key = uuidv4();
-        const e2eTest = await this.client.e2es?.createE2eTest(testDescription, { filePath: filePath ?? "", repoName, branchName, repoPath, key });
-        console.error("E2E test creation response:", JSON.stringify(e2eTest, null, 2));
-        const authToken = e2eTest?.tunnelKey;
-        if (!authToken) {
-            console.error("Failed to get auth token. E2E test response:", e2eTest);
-            console.error("Available keys in response:", e2eTest ? Object.keys(e2eTest) : 'null response');
-            return null;
-        }
-        await startTunnel(authToken, testPort, `${key}.ngrok.debugg.ai`);
-        console.error(`E2E test created - ${e2eTest}`);
-        if (!e2eTest) {
-            console.error("Failed to create E2E test.");
-            return null;
-        }
-        if (!e2eTest.curRun) {
-            console.error("Failed to create E2E test run.");
-            return null;
-        }
-        return e2eTest.curRun;
-    }
-    /**
-     * Poll an E2E run until it completes or times out.
-     *
-     * Uses a safe async loop — no setInterval race conditions.
-     * The tunnel is stopped in a finally block so cleanup always runs
-     * regardless of how the loop exits (completion, timeout, or error).
-     *
-     * onUpdate is called on every poll tick so progress notifications
-     * fire at a steady cadence and keep the MCP connection alive.
-     */
-    async handleE2eRun(e2eRun, onUpdate) {
-        const tunnelUrl = `https://${e2eRun.key}.ngrok.debugg.ai`;
-        const startTime = Date.now();
-        let updatedRun = e2eRun;
-        console.error(`🔧 Handling E2E run - ${e2eRun.uuid}`);
-        console.error(`🌐 Tunnel: ${tunnelUrl}`);
-        try {
-            while (true) {
-                if (Date.now() - startTime >= TIMEOUT_MS) {
-                    console.error('⏰ E2E test timed out after 15 minutes');
-                    break;
-                }
-                await this._sleep(POLL_INTERVAL_MS);
-                try {
-                    const latestRun = await this.client.e2es?.getE2eRun(e2eRun.uuid);
-                    if (latestRun) {
-                        updatedRun = latestRun;
-                    }
-                }
-                catch (pollError) {
-                    console.error(`⚠️ Poll error (continuing): ${pollError}`);
-                }
-                console.error(`📡 Polled E2E run status: ${updatedRun.status}`);
-                // Always fire onUpdate — keeps MCP progress notifications alive
-                // even when the run is loading or the poll returned null
-                await onUpdate(updatedRun);
-                if (updatedRun.status === 'completed') {
-                    break;
-                }
-            }
-        }
-        finally {
-            await this._stopTunnel(tunnelUrl);
-        }
-        return updatedRun;
-    }
-    // Overridable in tests
-    async _sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async _stopTunnel(url) {
-        await stopTunnel(url);
-    }
-}
-export default E2eTestRunner;

package/dist/e2e-agents/recordingHandler.js

@@ -1,57 +0,0 @@
-import * as fs from "fs";
-import * as http from "http";
-import * as https from "https";
-import * as path from "path";
-import { URL } from "url";
-export async function fetchAndOpenGif(projectRoot, recordingUrl, testName, testId) {
-    const cacheDir = path.join(projectRoot, ".debugg-ai", "e2e-runs");
-    console.error('....downloading gif....');
-    console.error('cacheDir', cacheDir);
-    console.error('testId', testId);
-    console.error('recordingUrl', recordingUrl);
-    let localUrl = recordingUrl.replace('localhost', 'localhost:8002');
-    console.error('localUrl', localUrl);
-    await fs.promises.mkdir(cacheDir, { recursive: true });
-    const filePath = path.join(cacheDir, `${testName.replace(/[^a-zA-Z0-9]/g, '-')}-${testId.slice(0, 4)}.gif`);
-    const fileUrl = new URL(localUrl);
-    const file = fs.createWriteStream(filePath);
-    console.error(`⬇️ Downloading test recording...`);
-    await new Promise((resolve, reject) => {
-        console.error('fetching gif', fileUrl);
-        if (fileUrl.protocol === 'https:') {
-            https.get(localUrl, (response) => {
-                if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download file: ${response.statusCode}`));
-                    return;
-                }
-                response.pipe(file);
-                file.on("finish", () => {
-                    file.close();
-                    resolve();
-                });
-            }).on("error", (err) => {
-                fs.unlinkSync(filePath);
-                reject(err);
-            });
-        }
-        else {
-            http.get(localUrl, (response) => {
-                if (response.statusCode !== 200) {
-                    reject(new Error(`Failed to download file: ${response.statusCode}`));
-                    return;
-                }
-                response.pipe(file);
-                file.on("finish", () => {
-                    file.close();
-                    resolve();
-                });
-            }).on("error", (err) => {
-                fs.unlinkSync(filePath);
-                reject(err);
-            });
-        }
-    });
-    console.error(`📂 Opening test recording`);
-    // const fileUri = vscode.Uri.file(filePath);
-    // await vscode.commands.executeCommand('vscode.open', fileUri);
-}

package/dist/e2e-agents/resultsFormatter.js

@@ -1,102 +0,0 @@
-export class RunResultFormatter {
-    steps = [];
-    passed(result) {
-        return result.status === "completed" && result.outcome === "pass";
-    }
-    formatFailures(result) {
-        if (this.passed(result) || !result.outcome)
-            return "";
-        return "\n\n❌ Failures:" + "\n" + `> ${result.outcome}`;
-    }
-    formatStepsAsMarkdown() {
-        if (this.steps.length === 0)
-            return "";
-        return ("\n\n" +
-            this.steps
-                .map((s, idx) => {
-                const num = `Step ${idx + 1}:`;
-                const label = s.label.padEnd(30);
-                const icon = "✅ Success";
-                // s.status === "pending"
-                //     ? chalk.yellow("⏳ Pending")
-                //     : s.status === "success"
-                //         ? chalk.green("✅ Success")
-                //         : chalk.red("❌ Failed");
-                return `${num} ${label} ${icon}`;
-            })
-                .join("\n\n"));
-    }
-    updateStep(label, status) {
-        const existing = this.steps.find((s) => s.label === label);
-        if (existing) {
-            existing.status = status;
-        }
-        else {
-            this.steps.push({ label, status });
-        }
-        console.error('updating step. steps ->', this.steps);
-        // Clear terminal and redraw
-        console.error("\x1Bc"); // ANSI clear screen
-        console.error("🧪 E2E Test Progress" +
-            `\r\n${this.steps
-                .map((s, i) => {
-                const icon = s.status === "pending"
-                    ? "⏳"
-                    : s.status === "success"
-                        ? "✅"
-                        : "❌";
-                return `${`Step ${i + 1}:`} ${s.label.padEnd(30)} ${icon}`;
-            })
-                .join("\r\n")}`);
-    }
-    formatTerminalBox(result) {
-        const header = this.passed(result)
-            ? "✅ Test Passed"
-            : "❌ Test Failed";
-        const body = [
-            "Test: " + result.test?.name,
-            "Description: " + (result.test?.description ?? "None"),
-            "Duration: " + `${result.metrics?.executionTime ?? 0}s`,
-            "Status: " + result.status,
-            "Outcome: " + result.outcome,
-            this.formatStepsAsMarkdown(),
-            this.passed(result) ? "" : this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\n");
-        return `${header}\n${body}`;
-    }
-    formatMarkdownSummary(result) {
-        return [
-            `🧪 **Test Name:** ${result.test?.name ?? "Unknown"}`,
-            `📄 **Description:** ${result.test?.description ?? "None"}`,
-            `⏱ **Duration:** ${result.metrics?.executionTime ?? 0}s`,
-            `🔎 **Status:** ${result.status}`,
-            `📊 **Outcome:** ${result.outcome}`,
-            this.formatStepsAsMarkdown(),
-            this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\n")
-            .trim();
-    }
-    /*
-    Terminal uses different formatting than markdown.
-    */
-    terminalSummary(result) {
-        return [
-            `🧪 Test Name: ${result.test?.name ?? "Unknown"}`,
-            `📄 Description: ${result.test?.description ?? "None"}`,
-            `⏱ Duration: ${result.metrics?.executionTime ?? 0}s`,
-            `🔎 Status: ${result.status}`,
-            `📊 Outcome: ${result.outcome}`,
-            this.formatFailures(result),
-        ]
-            .filter(Boolean)
-            .join("\r\n")
-            .trim();
-    }
-    appendToTestRun(result) {
-        console.error(this.terminalSummary(result));
-    }
-}