@debugg-ai/debugg-ai-mcp 4.2.1 → 4.2.2

package/dist/handlers/testPageChangesHandler.js

@@ -12,7 +12,7 @@ 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, acquirePortRoute, releasePortRoute, sanitizeResponseUrls, touchTunnelById, } from '../utils/tunnelContext.js';
+import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, acquirePortRoute, releasePortRoute, sanitizeResponseUrls, touchTunnelById, retargetAuxiliaryUrl, } from '../utils/tunnelContext.js';
 import { randomUUID } from 'node:crypto';
 import { detectRepoName } from '../utils/gitContext.js';
 import { disposeUnhealthyTunnel } from '../utils/tunnelDisposition.js';
@@ -379,10 +379,33 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                 auth.environmentId = input.auth.environmentId;
             if (input.auth.precondition)
                 auth.precondition = input.auth.precondition;
-            if (input.auth.entryUrl)
-                auth.entryUrl = input.auth.entryUrl;
-            if (input.auth.deepUrl)
-                auth.deepUrl = input.auth.deepUrl;
+            // Bead go1m: entryUrl/deepUrl are URLs the run NAVIGATES, so they need the
+            // same localhost→tunnel rewrite `url` gets (contextData.targetUrl above).
+            // Forwarded verbatim they reached the remote browser as literal localhost
+            // and it dialled its own loopback: offscope_host + ERR_CONNECTION_REFUSED.
+            for (const field of ['entryUrl', 'deepUrl']) {
+                const supplied = input.auth[field];
+                if (!supplied)
+                    continue;
+                const rewrite = retargetAuxiliaryUrl(ctx, supplied);
+                if (!rewrite.ok) {
+                    const payload = {
+                        error: 'AuthUrlPortMismatch',
+                        message: `auth.${field} points at localhost:${rewrite.port} but url points at ` +
+                            `localhost:${rewrite.primaryPort}. A single call tunnels exactly one local ` +
+                            `port, so the remote browser cannot reach both. Put the login page and the ` +
+                            `target page on the same port, or drop auth.${field} and pass username/password ` +
+                            `at the top level so the agent signs in on the page it already reached.`,
+                        detail: { field, authPort: rewrite.port, urlPort: rewrite.primaryPort, url: originalUrl },
+                    };
+                    logger.warn(`check_app_in_browser: ${payload.message}`);
+                    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }], isError: true };
+                }
+                auth[field] = rewrite.url;
+                if (rewrite.rewritten) {
+                    logger.info(`check_app_in_browser: tunneled auth.${field} ${supplied} -> ${rewrite.url}`);
+                }
+            }
             // WHICH account the precondition logs in as. Absent → the environment's
             // default credential (the pre-existing behaviour, correct for a caller
             // that named nobody).

package/dist/utils/tunnelContext.js

@@ -69,6 +69,46 @@ export async function ensureTunnel(ctx, tunnelKey, tunnelId, keyId, revokeKey) {
     const info = await tunnelManager.ensureSessionTunnel(getSessionKey(), tunnelKey, tunnelId, keyId, revokeKey);
     return { ...ctx, tunnelId: info.tunnelId, targetUrl: retargetTunnelUrl(info.tunnelUrl, ctx.originalUrl) };
 }
+/**
+ * Retarget an auxiliary URL the CALLER supplied (`auth.entryUrl`, `auth.deepUrl`)
+ * onto the same tunnel the run's primary `url` already uses.
+ *
+ * Bead go1m: only the top-level `url` ever went through the localhost→tunnel
+ * rewrite. `auth.entryUrl`/`auth.deepUrl` were forwarded verbatim, so a
+ * localhost entry URL reached the REMOTE browser as a literal `localhost:PORT`
+ * and it dialled its own loopback — `offscope_host` + ERR_CONNECTION_REFUSED on
+ * the documented "log in THEN deep-navigate" path. Every URL the run may
+ * navigate has to go through the same rewrite as `url`.
+ *
+ * Three cases, deliberately distinguished:
+ *  - not localhost (public URL, or dev mode / no tunnel) → returned unchanged.
+ *    Matches how the primary `url` is treated in those same conditions.
+ *  - localhost on the SAME port as the primary URL → retargeted onto the
+ *    tunnel origin, preserving path + query + hash (`retargetTunnelUrl`).
+ *  - localhost on a DIFFERENT port → REFUSED, never silently retargeted. The
+ *    session's single Caddy upstream is pointed at the primary URL's port for
+ *    the whole call (see `acquirePortRoute`), so rewriting a cross-port URL
+ *    onto the same origin would send the login navigation to whichever port
+ *    Caddy happens to hold — the silent misdirection the port lock exists to
+ *    prevent. Fail fast and tell the caller instead.
+ */
+export function retargetAuxiliaryUrl(ctx, auxUrl) {
+    // No tunnel in play (public target, or dev mode where the backend reaches
+    // localhost directly): the primary URL isn't rewritten either, so neither is this.
+    if (!ctx.isLocalhost || !ctx.tunnelId || !ctx.targetUrl) {
+        return { ok: true, url: auxUrl, rewritten: false };
+    }
+    // A public auxiliary URL is reachable by the remote browser as-is.
+    if (!isLocalhostUrl(auxUrl)) {
+        return { ok: true, url: auxUrl, rewritten: false };
+    }
+    const port = extractLocalhostPort(auxUrl);
+    const primaryPort = extractLocalhostPort(ctx.originalUrl);
+    if (port !== undefined && primaryPort !== undefined && port !== primaryPort) {
+        return { ok: false, reason: 'port_mismatch', port, primaryPort };
+    }
+    return { ok: true, url: retargetTunnelUrl(ctx.targetUrl, auxUrl), rewritten: true };
+}
 // ─── Port route lock (§2.4) ──────────────────────────────────────────────────
 /**
  * Acquire this session's shared Caddy route for `ctx`'s port, blocking until

package/package.json

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