@debugg-ai/debugg-ai-mcp 4.3.0 → 4.4.0

package/dist/handlers/probePageHandler.js

@@ -104,7 +104,10 @@ export async function probePageHandler(input, context, rawProgressCallback) {
     // Per-target tunnel contexts. Index aligns with input.targets[].
     const targetContexts = [];
     // Tunnel keys we provisioned this call (for cleanup if creation fails after key acquired).
-    const acquiredKeyIds = [];
+    // The provisions this call acquired, in target order. Provisions rather than
+    // bare key ids because revoking follows the transport the backend picked
+    // (ngrok keys and debugg tunnels have different endpoints).
+    const acquiredProvisions = [];
     // Progress budget: 1 pre-flight + 1 template + 1 execute + N per-target captures + 1 done
     const TOTAL_STEPS = 3 + input.targets.length + 1;
     let progressStep = 0;
@@ -157,10 +160,10 @@ export async function probePageHandler(input, context, rawProgressCallback) {
                             throw new Error(`Failed to provision tunnel for ${ctx.originalUrl}. ` +
                                 `(Detail: ${msg})${diag}`);
                         }
-                        acquiredKeyIds.push(tunnel.keyId);
+                        acquiredProvisions.push(tunnel);
                         let tunneled;
                         try {
-                            tunneled = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                            tunneled = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.tunnels.revoke(tunnel), tunnel);
                         }
                         catch (tunnelError) {
                             const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
@@ -463,11 +466,15 @@ export async function probePageHandler(input, context, rawProgressCallback) {
         // Tunnels intentionally NOT torn down — reuse pattern (bead vwd) +
         // 55-min idle auto-shutoff. Revoke only orphaned keys (we acquired the
         // key but tunnel creation failed before ensureTunnel completed).
-        for (let i = 0; i < acquiredKeyIds.length; i++) {
-            const keyId = acquiredKeyIds[i];
+        // NOTE (bead debugg_ai_mcp-xkoh.9): `tc` is undefined when ensureTunnel
+        // threw, so this condition does not fire on the very path it describes.
+        // That is a pre-existing defect with its own bead and is deliberately NOT
+        // fixed here; only the endpoint the revoke goes to changed.
+        for (let i = 0; i < acquiredProvisions.length; i++) {
+            const provision = acquiredProvisions[i];
             const tc = targetContexts[i];
-            if (tc && !tc.tunnelId && keyId) {
-                client.revokeNgrokKey(keyId).catch(err => logger.warn(`Failed to revoke unused ngrok key ${keyId}: ${err}`));
+            if (tc && !tc.tunnelId && provision) {
+                client.tunnels.revoke(provision).catch(err => logger.warn(`Failed to revoke unused tunnel ${provision.tunnelId}: ${err}`));
             }
         }
     }

package/dist/handlers/runTestSuiteHandler.js

@@ -18,7 +18,7 @@ export async function runTestSuiteHandler(input, _context) {
     logger.toolStart('run_test_suite', input);
     const client = new DebuggAIServerClient(config.api.key);
     await client.init();
-    let acquiredKeyId = null;
+    let acquiredProvision = null;
     let tunnelId;
     // Used ONLY to scope the defensive sanitizeResponseUrls call below (bead
     // debugg_ai_mcp-6cfv.7) — never fed into acquirePortRoute/PortLock. This
@@ -79,10 +79,10 @@ export async function runTestSuiteHandler(input, _context) {
                         const diag = provisionError instanceof TunnelProvisionError ? ` ${provisionError.diagnosticSuffix()}` : '';
                         return errorResp('TunnelProvisionFailed', `Failed to provision tunnel for ${input.targetUrl}. (Detail: ${msg})${diag}`);
                     }
-                    acquiredKeyId = tunnel.keyId;
+                    acquiredProvision = tunnel;
                     let dedicated;
                     try {
-                        dedicated = await tunnelManager.acquireDedicatedTunnel(ctx.originalUrl, tunnel.tunnelKey, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                        dedicated = await tunnelManager.acquireDedicatedTunnel(ctx.originalUrl, tunnel.tunnelKey, tunnel.keyId, () => client.tunnels.revoke(tunnel), tunnel);
                     }
                     catch (tunnelError) {
                         const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
@@ -142,8 +142,9 @@ export async function runTestSuiteHandler(input, _context) {
     finally {
         // Tunnels are NOT torn down — reuse pattern + 55-min idle auto-shutoff.
         // Only revoke an orphaned key (acquired but tunnel creation failed).
-        if (acquiredKeyId && !tunnelId) {
-            client.revokeNgrokKey(acquiredKeyId).catch((err) => logger.warn(`Failed to revoke unused ngrok key ${acquiredKeyId}: ${err}`));
+        if (acquiredProvision && !tunnelId) {
+            const orphan = acquiredProvision;
+            client.tunnels.revoke(orphan).catch((err) => logger.warn(`Failed to revoke unused tunnel ${orphan.tunnelId}: ${err}`));
         }
     }
 }

package/dist/handlers/testPageChangesHandler.js

@@ -135,7 +135,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
     await client.init();
     const originalUrl = resolveTargetUrl(input);
     let ctx = buildContext(originalUrl);
-    let keyId;
+    let provision;
     // Cancellation is driven by the MCP request/transport lifecycle, not
     // process.stdin. The SDK aborts context.signal when the client cancels the
     // call OR the transport closes — e.g. an HTTP client drops the connection.
@@ -249,7 +249,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                             `Make sure your dev server is running on the specified port and try again. ` +
                             `(Detail: ${msg})${diag}`);
                     }
-                    keyId = tunnel.keyId;
+                    provision = tunnel;
                     try {
                         ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
                     }
@@ -309,7 +309,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                         // owned path already revokes it; if we kept the tunnel, the key is that
                         // live tunnel's own credential and revoking it would kill what we just
                         // decided to preserve.
-                        keyId = undefined;
+                        provision = undefined;
                         return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                     }
                 }
@@ -993,9 +993,11 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         // subsequent calls to the same port and auto-shutoffs after 55 min idle.
         // Process-exit cleanup happens via stopAllTunnels() in the SIGINT/SIGTERM
         // handlers in index.ts.
-        if (!ctx.tunnelId && keyId) {
-            // Provisioned a key but tunnel creation failed — revoke the orphaned key.
-            client.revokeNgrokKey(keyId).catch(err => logger.warn(`Failed to revoke unused ngrok key ${keyId}: ${err}`));
+        if (!ctx.tunnelId && provision) {
+            // Provisioned a tunnel but creation failed — revoke it, through whichever
+            // endpoint its transport uses.
+            const orphan = provision;
+            client.tunnels.revoke(orphan).catch(err => logger.warn(`Failed to revoke unused tunnel ${orphan.tunnelId}: ${err}`));
         }
     }
 }

package/dist/handlers/triggerCrawlHandler.js

@@ -60,7 +60,7 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
     await client.init();
     const originalUrl = resolveTargetUrl(input);
     let ctx = buildContext(originalUrl);
-    let keyId;
+    let provision;
     // Bead 56kd.7: cancellation is driven by the MCP request/transport lifecycle
     // (context.signal), NOT process.stdin. The SDK aborts context.signal when the
     // client cancels the call OR the transport closes — e.g. an HTTP client drops
@@ -123,8 +123,8 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                             `The remote browser needs a secure tunnel to reach your local dev server. ` +
                             `(Detail: ${msg})${diag}`);
                     }
-                    keyId = tunnel.keyId;
-                    ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
+                    provision = tunnel;
+                    ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.tunnels.revoke(tunnel), tunnel);
                 }
                 // §2.4: acquire this session's shared Caddy route for our port BEFORE
                 // probing/dispatching — trigger_crawl polls (pollExecution below) for
@@ -169,7 +169,7 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                         // owned path already revokes it; if we kept the tunnel, the key is that
                         // live tunnel's own credential and revoking it would kill what we just
                         // decided to preserve.
-                        keyId = undefined;
+                        provision = undefined;
                         return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                     }
                 }
@@ -363,8 +363,9 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
         releasePortRoute(ctx);
         // Tunnel intentionally NOT torn down (reuse path per bead vwd).
         // If tunnel creation failed after key provision, revoke the orphaned key.
-        if (!ctx.tunnelId && keyId) {
-            client.revokeNgrokKey(keyId).catch(err => logger.warn(`Failed to revoke unused ngrok key ${keyId}: ${err}`));
+        if (!ctx.tunnelId && provision) {
+            const orphan = provision;
+            client.tunnels.revoke(orphan).catch(err => logger.warn(`Failed to revoke unused tunnel ${orphan.tunnelId}: ${err}`));
         }
     }
 }