@debugg-ai/debugg-ai-mcp 3.7.2 → 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

@@ -18,7 +18,7 @@
  */
 import { Logger } from '../../utils/logger.js';
 import { Telemetry, TelemetryEvents } from '../../utils/telemetry.js';
-import { isLocalhostUrl, extractLocalhostPort, generateTunnelUrl } from '../../utils/urlParser.js';
+import { isLocalhostUrl, extractLocalhostPort, generateTunnelUrl, retargetTunnelUrl } from '../../utils/urlParser.js';
 import { v4 as uuidv4 } from 'uuid';
 import { FaultInjector, TunnelTrace, getFaultModeFromEnv } from './tunnelFaultInjection.js';
 import { getDefaultRegistry, } from './tunnelRegistry.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)
@@ -262,9 +298,11 @@ class TunnelManager {
         // 1. Check local in-process map (handles owned + borrowed with liveness check)
         const existing = this.getTunnelForPort(port);
         if (existing) {
-            logger.info(`Reusing existing tunnel for port ${port}: ${existing.publicUrl}`);
+            // Bead zmc9: retarget to THIS caller's path; publicUrl carries the creator's.
+            const url_ = retargetTunnelUrl(existing.tunnelUrl, url);
+            logger.info(`Reusing existing tunnel for port ${port}: ${url_}`);
             Telemetry.capture(TelemetryEvents.TUNNEL_PROVISIONED, { port, how: 'reused' });
-            return { url: existing.publicUrl, tunnelId: existing.tunnelId, isLocalhost: true };
+            return { url: url_, tunnelId: existing.tunnelId, isLocalhost: true };
         }
         // 2. Deduplicate concurrent creation requests for the same port
         const pending = this.pendingTunnels.get(port);
@@ -277,7 +315,8 @@ class TunnelManager {
                 revokeKey().catch((err) => logger.warn(`Failed to revoke redundant key while joining pending tunnel for port ${port}:`, err));
             }
             const info = await pending;
-            return { url: info.publicUrl, tunnelId: info.tunnelId, isLocalhost: true };
+            // Bead zmc9: retarget to THIS caller's path, not the in-flight creator's.
+            return { url: retargetTunnelUrl(info.tunnelUrl, url), tunnelId: info.tunnelId, isLocalhost: true };
         }
         // 3. Check cross-process registry — another MCP instance may own a tunnel.
         //    Borrow only if the entry is fresh (PID alive AND touched within
@@ -303,7 +342,9 @@ class TunnelManager {
             this.reg.write(registry);
             this.resetTunnelTimer(borrowed);
             Telemetry.capture(TelemetryEvents.TUNNEL_PROVISIONED, { port, how: 'borrowed' });
-            return { url: regEntry.publicUrl, tunnelId: regEntry.tunnelId, isLocalhost: true };
+            // Bead zmc9: retarget to THIS caller's path; regEntry.publicUrl carries the
+            // owning PID's creating-call path — replaying it is the cross-session poison.
+            return { url: retargetTunnelUrl(regEntry.tunnelUrl, url), tunnelId: regEntry.tunnelId, isLocalhost: true };
         }
         // 4. Create a new tunnel (this process becomes the owner)
         const creationPromise = this.createTunnel(url, port, tunnelId, authToken, keyId, revokeKey);

package/dist/utils/tunnelContext.js

@@ -7,7 +7,7 @@
  *  - sanitizing backend responses so callers only ever see the original URL
  */
 import { tunnelManager } from '../services/ngrok/tunnelManager.js';
-import { isLocalhostUrl, replaceTunnelUrls, extractLocalhostPort } from './urlParser.js';
+import { isLocalhostUrl, replaceTunnelUrls, extractLocalhostPort, retargetTunnelUrl } from './urlParser.js';
 // ─── URL resolution ──────────────────────────────────────────────────────────
 /**
  * Resolve tool input to a concrete URL string.
@@ -43,7 +43,13 @@ export function findExistingTunnel(ctx) {
     if (!existing)
         return null;
     tunnelManager.touchTunnel(existing.tunnelId);
-    return { ...ctx, tunnelId: existing.tunnelId, targetUrl: existing.publicUrl };
+    // Bead zmc9: retarget to THIS caller's path — never replay existing.publicUrl,
+    // which carries the path of whichever call created the (port-keyed) tunnel.
+    return {
+        ...ctx,
+        tunnelId: existing.tunnelId,
+        targetUrl: retargetTunnelUrl(existing.tunnelUrl, ctx.originalUrl),
+    };
 }
 /**
  * Create (or reuse) a tunnel for a localhost URL.

package/dist/utils/urlParser.js

@@ -107,6 +107,28 @@ export function replaceTunnelUrls(value, localhostOrigin) {
     }
     return value;
 }
+/**
+ * Re-point a REUSED tunnel at the current caller's path (bead zmc9).
+ *
+ * A tunnel is origin-scoped: its `tunnelUrl` (scheme://host from ngrok) forwards
+ * every path. The path is request-scoped. On reuse we must compose the reused
+ * tunnel's ORIGIN with THIS request's path/search/hash — never replay the
+ * path-bearing `publicUrl` baked in by whichever call created the tunnel.
+ *
+ * @param tunnelOrigin the reused tunnel's path-free origin (TunnelInfo.tunnelUrl)
+ * @param requestedUrl the localhost URL the current caller asked for
+ */
+export function retargetTunnelUrl(tunnelOrigin, requestedUrl) {
+    try {
+        const origin = new URL(tunnelOrigin);
+        const parsed = parseUrl(requestedUrl);
+        return `${origin.protocol}//${origin.host}${parsed.pathname}${parsed.search}${parsed.hash}`;
+    }
+    catch {
+        // Never fabricate a path: fall back to the bare origin, not a foreign path.
+        return tunnelOrigin;
+    }
+}
 /**
  * Generate a tunneled URL for a localhost URL
  */

package/package.json

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