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

package/dist/handlers/liveSessionHandlers.js

@@ -76,9 +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 account ngrok auth token
+        // If we need a tunnel, create it now using the tunnel key from the session response
         if (isLocalhost && tunnelId) {
-            const tunnelAuthToken = await client.getNgrokAuthToken();
+            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,29 +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`;
-            const tunnelAuthToken = await client.getNgrokAuthToken();
-            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();
@@ -70,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) => {
@@ -105,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,
         };
@@ -142,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

@@ -38,8 +38,6 @@ export class DebuggAIServerClient {
     e2es;
     browserSessions;
     workflows;
-    // Cached ngrok auth token — stable per account, fetched once per server session
-    _ngrokAuthToken;
     constructor(userApiKey) {
         this.userApiKey = userApiKey;
         // Note: init() is async and should be called separately
@@ -53,31 +51,13 @@ export class DebuggAIServerClient {
         this.workflows = createWorkflowsService(this.tx);
     }
     /**
-     * Returns the ngrok auth token for this account.
-     * The token is stable per account — fetched once via a minimal e2e test creation
-     * and cached for the lifetime of this server session.
+     * Revoke an ngrok API key by its key ID.
+     * Call this after workflow execution completes to clean up the short-lived key.
      */
-    async getNgrokAuthToken() {
-        if (this._ngrokAuthToken)
-            return this._ngrokAuthToken;
+    async revokeNgrokKey(ngrokKeyId) {
         if (!this.tx)
             throw new Error('Client not initialized — call init() first');
-        // The e2e-tests POST returns tunnel_key (stable per account) at creation time.
-        // We create a minimal probe test, extract the key, then delete the test.
-        const created = await this.tx.post('api/v1/e2e-tests/', {
-            description: '_mcp_tunnel_probe',
-            repoName: '_mcp',
-            branchName: 'main',
-        });
-        const token = created?.tunnelKey;
-        if (!token)
-            throw new Error('Backend did not return a tunnel auth token');
-        // Clean up the probe test
-        if (created?.uuid) {
-            this.tx.delete(`api/v1/e2e-tests/${created.uuid}/`).catch(() => { });
-        }
-        this._ngrokAuthToken = token;
-        return token;
+        await this.tx.post('api/v1/ngrok/revoke/', { ngrokKeyId });
     }
 }
 /**

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.24",
+  "version": "1.0.25",
   "description": "Zero-Config, Fully AI-Managed End-to-End Testing for all code gen platforms.",
   "type": "module",
   "bin": {