@debugg-ai/debugg-ai-mcp 2.0.3 → 2.0.4

package/CHANGELOG.md

@@ -10,9 +10,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed — tunnel provisioning flakiness surfaces as user-facing errors
 
 - `check_app_in_browser` / `trigger_crawl` now automatically retry transient tunnel-provision failures (5xx, 408, 429, network errors like ECONNRESET) with exponential backoff (500ms → 1500ms → 3000ms, 3 attempts). Previously a single ngrok/backend blip forced the caller to manually retry the tool call. Bead `7nx`.
+- **ngrok.connect() retry widened from 2 to 3 attempts** with 500ms / 1500ms backoff. A client still hit "Tunnel setup failed" after `7nx` shipped — the failure was in the ngrok-listener-bringup path, not the backend-provision path. Auth errors still fail fast. Bead `ixh`.
 - Tunnel-provision error messages now carry structured diagnostic context — HTTP status, ngrok error code, backend `x-request-id`, retryable flag — so users have something actionable to file bug reports against instead of opaque "Tunnel setup failed". Bead `5wz`.
 - 4xx auth/quota errors (401/403/404) fail fast without retry to avoid loops against a bad API key.
-- New posthog telemetry event `tunnel.provision_retry` fires per retry attempt with outcome, status, and diagnostic fields so flaky provision rates become measurable.
+- New posthog telemetry event `tunnel.provision_retry` fires per retry attempt with outcome, status, stage (`ngrok_connect` vs backend-provision), and diagnostic fields so flaky rates become measurable.
 
 ## [2.0.0] - 2026-04-23
 

package/dist/services/ngrok/tunnelManager.js

@@ -48,6 +48,12 @@ class TunnelManager {
     pendingTunnels = new Map();
     initialized = false;
     TUNNEL_TIMEOUT_MS = 55 * 60 * 1000;
+    /**
+     * Backoff schedule (ms) between ngrok.connect() retry attempts. Bead ixh.
+     * Exposed on the class so tests can override with short delays without
+     * changing the public API or depending on jest fake timers.
+     */
+    connectBackoffMs = [500, 1500];
     constructor(reg = getDefaultRegistry()) {
         this.reg = reg;
     }
@@ -266,37 +272,80 @@ class TunnelManager {
         else {
             localAddr = inDocker ? `${dockerHost}:${port}` : port;
         }
+        // Bead ixh: 3-attempt retry for ngrok.connect transient failures. Previously
+        // only retried ONCE (with agent reset), which is insufficient against real
+        // ngrok / network flakes (client-reported incident 2026-04-24).
+        // - Attempt 1: fresh connect
+        // - Attempt 2: after 500ms backoff, reset the ngrok agent module and retry
+        //   (existing "agent died" recovery path)
+        // - Attempt 3: after 1500ms backoff, retry with the already-reset agent
+        // Auth-token errors short-circuit at any attempt — no point looping.
+        const self = this;
         const connectWithRetry = async () => {
-            try {
-                const ngrok = await getNgrok();
-                const url = await ngrok.connect({
-                    proto: 'http',
-                    addr: localAddr,
-                    hostname: tunnelDomain,
-                    authtoken: authToken,
-                });
-                if (!url)
-                    throw new Error('ngrok.connect() returned empty URL');
-                return url;
-            }
-            catch (firstError) {
-                // The ngrok agent process may have died after a previous disconnect.
-                // Reset module state and retry once with a fresh agent.
-                logger.warn(`ngrok.connect() failed, retrying with fresh agent: ${firstError}`);
-                resetNgrokModule();
-                this.initialized = false;
-                await this.ensureInitialized();
-                const ngrok = await getNgrok();
-                const url = await ngrok.connect({
-                    proto: 'http',
-                    addr: localAddr,
-                    hostname: tunnelDomain,
-                    authtoken: authToken,
-                });
-                if (!url)
-                    throw new Error('ngrok.connect() returned empty URL after retry');
-                return url;
+            const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+            const BACKOFF_MS = self.connectBackoffMs; // bead ixh: test-overridable
+            const MAX_ATTEMPTS = BACKOFF_MS.length + 1; // N sleeps between N+1 attempts
+            const connectOpts = {
+                proto: 'http',
+                addr: localAddr,
+                hostname: tunnelDomain,
+                authtoken: authToken,
+            };
+            let lastError;
+            for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+                try {
+                    const ngrok = await getNgrok();
+                    const url = await ngrok.connect(connectOpts);
+                    if (!url)
+                        throw new Error(`ngrok.connect() returned empty URL (attempt ${attempt})`);
+                    if (attempt > 1) {
+                        Telemetry.capture(TelemetryEvents.TUNNEL_PROVISION_RETRY, {
+                            attempt,
+                            outcome: 'success',
+                            stage: 'ngrok_connect',
+                        });
+                    }
+                    return url;
+                }
+                catch (err) {
+                    lastError = err;
+                    const msg = err instanceof Error ? err.message : String(err);
+                    // Auth-class errors are non-retryable — retrying with the same token
+                    // would loop. Let the outer catch (line ~437) classify the message.
+                    if (/authtoken|unauthorized|\b401\b|\b403\b/i.test(msg)) {
+                        Telemetry.capture(TelemetryEvents.TUNNEL_PROVISION_RETRY, {
+                            attempt,
+                            outcome: 'giving-up',
+                            stage: 'ngrok_connect',
+                            reason: 'auth-error',
+                        });
+                        throw err;
+                    }
+                    const isLastAttempt = attempt >= MAX_ATTEMPTS;
+                    Telemetry.capture(TelemetryEvents.TUNNEL_PROVISION_RETRY, {
+                        attempt,
+                        outcome: isLastAttempt ? 'giving-up' : 'will-retry',
+                        stage: 'ngrok_connect',
+                    });
+                    if (isLastAttempt)
+                        throw err;
+                    // Between attempt 1→2, do an agent-reset (covers the "agent died"
+                    // failure mode that used to be the only retried case). Between 2→3,
+                    // just wait — the reset already happened.
+                    if (attempt === 1) {
+                        logger.warn(`ngrok.connect() failed (attempt 1/${MAX_ATTEMPTS}), resetting agent: ${msg}`);
+                        resetNgrokModule();
+                        this.initialized = false;
+                        await this.ensureInitialized();
+                    }
+                    else {
+                        logger.warn(`ngrok.connect() failed (attempt ${attempt}/${MAX_ATTEMPTS}), will retry: ${msg}`);
+                    }
+                    await sleep(BACKOFF_MS[attempt - 1] ?? BACKOFF_MS[BACKOFF_MS.length - 1]);
+                }
             }
+            // Unreachable (loop always returns or throws), but satisfy TS
+            throw lastError ?? new Error('connectWithRetry: exhausted attempts without error');
         };
         try {
             const tunnelUrl = await connectWithRetry();

package/package.json

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