@debugg-ai/debugg-ai-mcp 3.10.0 → 4.1.0

package/dist/handlers/testPageChangesHandler.js

@@ -11,7 +11,8 @@ import { DebuggAIServerClient } from '../services/index.js';
 import { getEvalTemplateSlug } from '../services/workflows.js';
 import { adaptVerdict, isEnvironmentDefault } from '../services/verdictAdapter.js';
 import { TunnelProvisionError } from '../services/tunnels.js';
-import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, acquirePortRoute, releasePortRoute, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { randomUUID } from 'node:crypto';
 import { detectRepoName } from '../utils/gitContext.js';
 import { disposeUnhealthyTunnel } from '../utils/tunnelDisposition.js';
 import { probeLocalPort, probeTunnelHealth, extractNgrokErrorCode } from '../utils/localReachability.js';
@@ -175,6 +176,9 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
             logger.warn(`Best-effort cancel of abandoned execution ${uuid} threw synchronously: ${err}`);
         }
     };
+    // Unique per-call id for the shared port-route lock's holder bookkeeping
+    // (§2.4) — reused for abort wiring purposes elsewhere in this handler.
+    const callId = randomUUID();
     const abortController = new AbortController();
     const onAbort = () => {
         clientAborted = true;
@@ -257,6 +261,24 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                     }
                     logger.info(`Tunnel ready: ${ctx.targetUrl} (id: ${ctx.tunnelId})`);
                 }
+                // §2.4: acquire this session's shared Caddy route for our port BEFORE
+                // probing/dispatching — probing before the repoint is confirmed would
+                // probe whatever port happened to be active a moment ago. Blocks here
+                // (not just during the repoint) until any different-port holder in
+                // this same session releases.
+                ctx = await acquirePortRoute(ctx, {
+                    callId,
+                    signal: abortController.signal,
+                    onWaitProgress: progressCallback
+                        ? async (info) => {
+                            await progressCallback({
+                                progress: 1,
+                                total: TOTAL_STEPS,
+                                message: `Waiting for shared tunnel — port ${info.blockingPort} is in use (waited ${Math.round(info.waitedMs / 1000)}s)...`,
+                            });
+                        }
+                        : undefined,
+                });
                 // Bead 1om: verify traffic actually flows through the tunnel. The
                 // tunnel can be established (ngrok.connect returns OK) yet refuse
                 // to forward traffic — e.g., IPv4/IPv6 bind mismatch, or the dev
@@ -397,6 +419,12 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         if (input.useEnvironmentCredentials === false) {
             env.useEnvironmentCredentials = false;
         }
+        // Same rule for the session opt-out: send it only when it IS one, so the
+        // default (reuse a warm session when one exists for this account) is
+        // expressed by absence rather than by an explicit false.
+        if (input.freshSession === true) {
+            env.freshSession = true;
+        }
         // --- Execute ---
         // Log the SHAPE of env, never its secrets. It now carries per-account
         // passwords (taskCredentials), and this log line is not run through the
@@ -913,6 +941,10 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
     finally {
         if (requestSignal)
             requestSignal.removeEventListener('abort', onAbort);
+        // §2.4: release this call's claim on the shared port route (no-op if we
+        // never acquired one — public URL, dev mode, or an early-return before
+        // acquisition). Covers every early-return path above for free.
+        releasePortRoute(ctx);
         // Tunnel is intentionally NOT torn down here — tunnelManager reuses it on
         // subsequent calls to the same port and auto-shutoffs after 55 min idle.
         // Process-exit cleanup happens via stopAllTunnels() in the SIGINT/SIGTERM

package/dist/handlers/triggerCrawlHandler.js

@@ -18,7 +18,8 @@ import { TunnelProvisionError } from '../services/tunnels.js';
 import { disposeUnhealthyTunnel } from '../utils/tunnelDisposition.js';
 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 { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, acquirePortRoute, releasePortRoute, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { randomUUID } from 'node:crypto';
 import { getCachedTemplateUuid, invalidateTemplateCache } from '../utils/handlerCaches.js';
 import { detectLocalGitRef } from '../utils/gitContext.js';
 import { getCrawlTemplateSlug } from '../services/workflows.js';
@@ -67,6 +68,8 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
     // we get: stdin is not the transport, so the old stdin 'close' listener never
     // fired and a dropped client kept polling for up to ~10 min. Wiring to
     // context.signal cancels the poll immediately (parity with 56kd.5).
+    // Unique per-call id for the shared port-route lock's holder bookkeeping (§2.4).
+    const callId = randomUUID();
     const abortController = new AbortController();
     const onAbort = () => {
         abortController.abort();
@@ -123,6 +126,25 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
                     keyId = tunnel.keyId;
                     ctx = await ensureTunnel(ctx, tunnel.tunnelKey, tunnel.tunnelId, tunnel.keyId, () => client.revokeNgrokKey(tunnel.keyId));
                 }
+                // §2.4: acquire this session's shared Caddy route for our port BEFORE
+                // probing/dispatching — trigger_crawl polls (pollExecution below) for
+                // the full duration real backend traffic can occur, exactly like
+                // check_app_in_browser/probe_page, so it holds this lock for the
+                // whole call, not just the repoint (verified: it is NOT a
+                // fire-and-forget exception — only run_test_suite is, §2.3).
+                ctx = await acquirePortRoute(ctx, {
+                    callId,
+                    signal: abortController.signal,
+                    onWaitProgress: progressCallback
+                        ? async (info) => {
+                            await progressCallback({
+                                progress: 1,
+                                total: 4,
+                                message: `Waiting for shared tunnel — port ${info.blockingPort} is in use (waited ${Math.round(info.waitedMs / 1000)}s)...`,
+                            });
+                        }
+                        : undefined,
+                });
                 // Bead 1om: post-tunnel health check — verify traffic actually flows.
                 if (ctx.targetUrl) {
                     const health = await probeTunnelHealth(ctx.targetUrl);
@@ -336,6 +358,9 @@ export async function triggerCrawlHandler(input, context, rawProgressCallback) {
     finally {
         if (requestSignal)
             requestSignal.removeEventListener('abort', onAbort);
+        // §2.4: release this call's claim on the shared port route (no-op if we
+        // never acquired one).
+        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) {