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

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

@@ -20,6 +20,7 @@ import { probeLocalPort, probeTunnelHealth } from '../utils/localReachability.js
 import { extractLocalhostPort } from '../utils/urlParser.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
 import { getCachedTemplateUuid, invalidateTemplateCache } from '../utils/handlerCaches.js';
+import { detectLocalGitRef } from '../utils/gitContext.js';
 import { getCrawlTemplateSlug } from '../services/workflows.js';
 import { isTransientWorkflowError, transientReasonTag } from '../utils/transientErrors.js';
 import { Telemetry, TelemetryEvents } from '../utils/telemetry.js';
@@ -138,7 +139,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 };
@@ -170,6 +180,18 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
         contextData.headless = true; // D7: the MCP always runs headless — no opt-out.
         if (typeof input.timeoutSeconds === 'number')
             contextData.timeoutSeconds = input.timeoutSeconds;
+        // sentinal-lwtaw.13 (MCP side): the TRIGGER POINT owns the git fact. Attach
+        // the LOCAL checkout's branch + commit so the backend mints a git-backed
+        // Atlas version for this crawl — SAME snake_case contextData keys the
+        // PR-webhook path reads (commit_sha, branch). Best-effort + non-fatal:
+        // detectLocalGitRef never throws and a non-git target attaches nothing
+        // (honest no-git) and still crawls. Keys are set ONLY when present so we
+        // never fabricate a ref.
+        const gitRef = await detectLocalGitRef();
+        if (gitRef.commitSha)
+            contextData.commit_sha = gitRef.commitSha;
+        if (gitRef.branch)
+            contextData.branch = gitRef.branch;
         const env = {};
         if (input.environmentId)
             env.environmentId = input.environmentId;

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/dist/utils/gitContext.js

@@ -3,6 +3,9 @@
  * Parses the origin remote URL into "owner/repo" format.
  */
 import { execSync } from 'child_process';
+import { ProjectAnalyzer } from './projectAnalyzer.js';
+import { Logger } from './logger.js';
+const logger = new Logger({ module: 'gitContext' });
 let cached; // undefined = not yet checked
 /**
  * Detect the repo name (e.g. "debugg-ai/debugg-ai-frontend") from git remote origin.
@@ -25,6 +28,29 @@ export function detectRepoName() {
     }
     return cached;
 }
+/**
+ * Detect the LOCAL git ref (branch + commit sha) from the current working
+ * directory — the repo whose dev server the caller is crawling.
+ *
+ * sentinal-lwtaw.13 (MCP side): the TRIGGER POINT owns the git fact. The
+ * environment says WHERE to crawl; the caller supplies the ref it's running so
+ * the backend can mint a git-backed Atlas version. Delegates to
+ * ProjectAnalyzer's existing `.git/HEAD` readers — no new git parsing.
+ *
+ * Best-effort by contract: returns `{}` when cwd isn't a git repo (or the read
+ * fails). NEVER throws and NEVER fabricates a branch/sha — a git-less target
+ * must still crawl (honest no-git). NOT cached (unlike detectRepoName): the
+ * branch/commit change under a long-lived MCP process, so each crawl re-reads.
+ */
+export async function detectLocalGitRef() {
+    try {
+        return await new ProjectAnalyzer().getGitRef(process.cwd());
+    }
+    catch (err) {
+        logger.debug('Could not determine local git ref', err);
+        return {};
+    }
+}
 /**
  * Parse an origin URL into "owner/repo" format.
  * Handles SSH (git@github.com:owner/repo.git) and HTTPS (https://github.com/owner/repo.git).

package/dist/utils/projectAnalyzer.js

@@ -438,6 +438,29 @@ export class ProjectAnalyzer {
     extractRepoName(projectPath) {
         return projectPath.split('/').pop() || 'unknown';
     }
+    /**
+     * Best-effort local git ref (branch + full commit sha) for a project dir.
+     *
+     * Reuses the existing `.git/HEAD` readers (getCurrentBranch /
+     * getCurrentCommitHash) — no new git parsing. NEVER throws and NEVER
+     * fabricates: a non-git dir (or any read failure) yields `{}` so a git-less
+     * crawl target still crawls (honest no-git). Not cached — a long-lived MCP
+     * process must re-read after the caller checks out a branch or commits.
+     */
+    async getGitRef(repoPath) {
+        const projectPath = repoPath || process.cwd();
+        try {
+            const [branch, commitSha] = await Promise.all([
+                this.getCurrentBranch(projectPath),
+                this.getCurrentCommitHash(projectPath),
+            ]);
+            return { branch, commitSha };
+        }
+        catch (error) {
+            logger.debug('Could not determine local git ref', error);
+            return {};
+        }
+    }
     /**
      * Get current git branch (simplified)
      */

package/package.json

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