@debugg-ai/debugg-ai-mcp 3.7.3 → 3.7.4

package/dist/handlers/probePageHandler.js

@@ -149,7 +149,16 @@ export async function probePageHandler(input, context, rawProgressCallback) {
                                     },
                                 };
                                 if (tunneled.tunnelId) {
-                                    tunnelManager.stopTunnel(tunneled.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${tunneled.tunnelId}: ${err}`));
+                                    const deadPort = extractLocalhostPort(tunneled.originalUrl);
+                                    if (health.ngrokErrorCode && typeof deadPort === 'number') {
+                                        // Tunnel-level dead (ERR_NGROK_*): evict the SHARED registry entry
+                                        // so the next call re-provisions instead of re-borrowing the corpse
+                                        // (bead k34o) — plain stopTunnel leaves a borrowed entry to re-poison.
+                                        tunnelManager.markTunnelDead(deadPort, tunneled.tunnelId).catch((err) => logger.warn(`Failed to evict dead tunnel ${tunneled.tunnelId}: ${err}`));
+                                    }
+                                    else {
+                                        tunnelManager.stopTunnel(tunneled.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${tunneled.tunnelId}: ${err}`));
+                                    }
                                 }
                                 return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
                             }

package/dist/handlers/testPageChangesHandler.js

@@ -256,10 +256,17 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                         };
                         logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
                         // Tear down the broken tunnel so a subsequent call doesn't reuse it.
-                        // stopTunnel handles both owned (ngrok disconnect + key revoke) and
-                        // borrowed (just drops local ref) cases.
                         if (ctx.tunnelId) {
-                            tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                            const deadPort = extractLocalhostPort(ctx.originalUrl);
+                            if (health.ngrokErrorCode && typeof deadPort === 'number') {
+                                // Tunnel-level dead (ERR_NGROK_*): evict the SHARED registry entry
+                                // so the next call re-provisions instead of re-borrowing the corpse.
+                                // Plain stopTunnel leaves a borrowed entry to re-poison (bead k34o).
+                                tunnelManager.markTunnelDead(deadPort, ctx.tunnelId).catch((err) => logger.warn(`Failed to evict dead tunnel ${ctx.tunnelId}: ${err}`));
+                            }
+                            else {
+                                tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                            }
                         }
                         // keyId is consumed by stopTunnel's revoke path; clear so the
                         // outer finally block doesn't double-revoke.

package/dist/handlers/triggerCrawlHandler.js

@@ -138,7 +138,16 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                         };
                         logger.warn(`Tunnel health probe failed for ${ctx.targetUrl}: ${health.code} ${health.ngrokErrorCode ?? ''} in ${health.elapsedMs}ms`);
                         if (ctx.tunnelId) {
-                            tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                            const deadPort = extractLocalhostPort(ctx.originalUrl);
+                            if (health.ngrokErrorCode && typeof deadPort === 'number') {
+                                // Tunnel-level dead (ERR_NGROK_*): evict the SHARED registry entry so
+                                // the next call re-provisions instead of re-borrowing the corpse — plain
+                                // stopTunnel leaves a borrowed entry to re-poison (bead k34o).
+                                tunnelManager.markTunnelDead(deadPort, ctx.tunnelId).catch((err) => logger.warn(`Failed to evict dead tunnel ${ctx.tunnelId}: ${err}`));
+                            }
+                            else {
+                                tunnelManager.stopTunnel(ctx.tunnelId).catch((err) => logger.warn(`Failed to stop broken tunnel ${ctx.tunnelId}: ${err}`));
+                            }
                         }
                         keyId = undefined;
                         return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };

package/dist/services/ngrok/tunnelManager.js

@@ -148,6 +148,42 @@ class TunnelManager {
         }
         return existing;
     }
+    /**
+     * Evict a tunnel that a health probe PROVED dead (e.g. ERR_NGROK_3200) so no
+     * session borrows the corpse again (bead k34o).
+     *
+     * OWNED: delegate to stopTunnel — it already removes the registry entry,
+     * disconnects, revokes the key, and resets the agent. (Self-heals after one
+     * failure, which already worked.)
+     *
+     * BORROWED (the actual gap): stopTunnel only drops our local ref and leaves the
+     * SHARED registry entry, so every other session keeps re-borrowing the dead
+     * tunnel for up to the 30-min freshness TTL. Here we also evict the shared
+     * entry — guarded by tunnelId so a replacement another session just provisioned
+     * for the same port is never removed. Best-effort, never throws.
+     */
+    async markTunnelDead(port, tunnelId) {
+        const local = this.activeTunnels.get(tunnelId);
+        if (local?.isOwned) {
+            await this.stopTunnel(tunnelId).catch(() => { });
+            return;
+        }
+        // Borrowed or no longer local — drop any local ref, then evict the shared entry.
+        if (local?.autoShutoffTimer)
+            clearTimeout(local.autoShutoffTimer);
+        this.activeTunnels.delete(tunnelId);
+        try {
+            const registry = this.reg.read();
+            if (registry[String(port)]?.tunnelId === tunnelId) {
+                delete registry[String(port)];
+                this.reg.write(registry);
+                logger.info(`Evicted dead borrowed tunnel ${tunnelId} for port ${port} from shared registry`);
+            }
+        }
+        catch {
+            // best-effort — a failed eviction just means the next call re-probes and re-evicts
+        }
+    }
     touchTunnel(tunnelId) {
         const tunnelInfo = this.activeTunnels.get(tunnelId);
         if (!tunnelInfo)

package/package.json

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