@debugg-ai/debugg-ai-mcp 6.1.3 → 6.1.5

package/README.md

@@ -23,6 +23,30 @@ clear error on the first localhost-URL call, not a silent hang. Public-URL calls
 non-browser tool, and `test_suite {action:"run"}` (which uses its own dedicated tunnel and
 bypasses Caddy entirely) don't need it either way.
 
+## Testing a local app (no Tailscale, no port exposure)
+
+Start your app on localhost, then pass the `http://localhost:<port>` URL straight to the tool. The MCP
+opens its own DebuggAI tunnel (one per session, dialed through a local Caddy proxy) — do not expose the
+port with Tailscale, ngrok, or anything else, and do not rewrite the URL to a tunnel hostname yourself.
+
+```json
+probe_page            { "targets": [{ "url": "http://localhost:4040" }] }
+check_app_in_browser  { "url": "http://localhost:4040", "description": "Open the home page and confirm the hero renders" }
+```
+
+Verified 2026-11-10 against a Next.js dev server on `localhost:4040`: `probe_page` returned
+`statusCode 200`, title, 0 console errors, and every asset request resolved via the tunnel.
+Prerequisites: `DEBUGGAI_API_KEY` set for the MCP, the `caddy` binary available (see above), and the
+app actually listening (a dead port fails fast with `LocalServerUnreachable`). Several pages on the
+same port can share one `probe_page` call; mixing ports in one call works but runs serially.
+
+`TunnelTrafficBlocked` means the tunnel came up but the health probe through it got no valid response. First
+check you are on the latest MCP (`npx -y @debugg-ai/debugg-ai-mcp@latest`; a stale pinned version is the usual
+cause), then that your dev server answers a plain `curl http://127.0.0.1:<port>/` and does not reject unknown
+`Host` headers (tunnel requests carry the tunnel hostname; a gateway that routes by `Host` needs a catch-all).
+Verified 2026-11-10: servers bound to `127.0.0.1` only (IPv4 Caddy gateways on :4040 and :4043) probe fine via
+`http://localhost:<port>` and `http://127.0.0.1:<port>`.
+
 Get an API key at [debugg.ai](https://debugg.ai), then add to your MCP client config:
 
 ```json
@@ -78,6 +102,7 @@ Runs an AI browser agent against your app. The agent navigates, interacts, and r
 | `loginCredentials` | array | Accounts for logins the agent hits **during** the task — `[{username, password, label?}]` |
 | `useEnvironmentCredentials` | boolean | Default `true`. `false` forbids auto-filling the environment's stored credentials; with no account named it means **do not log in at all** |
 | `freshSession` | boolean | Default `false`. `true` forces a real login instead of reusing the warm session held for that account |
+| `extraOrigins` | string[] | Extra local origins the run may be redirected to, e.g. `["http://host.docker.internal:4717", "http://localhost:4304"]` (OAuth vendor + callback on other ports). Redirects to them (and back to `url`) are followed through the tunnel; pages on them are served at `/__o/<port>/`. Only listed origins are exposed. Absolute URLs written inside page HTML (not redirects) are not rewritten |
 | `auth` | object | Auth precondition — `{precondition, entryUrl, deepUrl, environmentId, username, password}` |
 | `repoName` | string | Override auto-detected git repo name (e.g. `my-org/my-repo`) |
 

package/dist/handlers/testPageChangesHandler.js

@@ -10,7 +10,9 @@ import { handleExternalServiceError } from '../utils/errors.js';
 import { fetchImageAsBase64, imageContentBlock, resourceLinkBlock, artifactResourceLinks } from '../utils/imageUtils.js';
 import { DebuggAIServerClient } from '../services/index.js';
 import { getEvalTemplateSlug } from '../services/workflows.js';
-import { adaptVerdict, credentialSubstitutions } from '../services/verdictAdapter.js';
+import { authorizeExtraOrigins, ExtraOriginError } from '../utils/extraOrigins.js';
+import { refreshPendingArtifacts } from '../utils/artifactGrace.js';
+import { adaptVerdict, credentialSubstitutions, summarizeLogins } from '../services/verdictAdapter.js';
 import { TunnelProvisionError } from '../services/tunnels.js';
 import { resolveTargetUrl, buildContext, findExistingTunnel, ensureTunnel, acquirePortRoute, releasePortRoute, sanitizeResponseUrls, touchTunnelById, retargetAuxiliaryUrl, } from '../utils/tunnelContext.js';
 import { randomUUID } from 'node:crypto';
@@ -318,6 +320,18 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                         }
                         : undefined,
                 });
+                // Bead w1os.2: extra local origins (OAuth vendor, callback) this run may
+                // be redirected to. Needs the route held; validated here so a bad entry
+                // fails fast with a plain message instead of mid-run.
+                try {
+                    ctx = await authorizeExtraOrigins(ctx, input.extraOrigins);
+                }
+                catch (err) {
+                    if (err instanceof ExtraOriginError) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ error: 'InvalidExtraOrigin', message: err.message }, null, 2) }], isError: true };
+                    }
+                    throw err;
+                }
                 // Bead 1om: verify traffic actually flows through the tunnel. The
                 // tunnel can be established (connect returns OK) yet refuse
                 // to forward traffic — e.g., IPv4/IPv6 bind mismatch, or the dev
@@ -494,6 +508,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         let executeResponse;
         let executionUuid = '';
         let finalExecution;
+        let execStartedAtMs;
         let attempt = 0;
         while (true) {
             attempt++;
@@ -516,6 +531,8 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
                 }
                 await new Promise(r => setTimeout(r, 1000 * (attempt - 1)));
             }
+            const execStartedAt = Date.now();
+            execStartedAtMs = execStartedAt;
             executeResponse = await client.workflows.executeWorkflow(templateUuid, contextData, Object.keys(env).length > 0 ? env : undefined);
             executionUuid = executeResponse.executionUuid;
             // Bead 5er7: this is now the execution an abort must cancel (a retry moves
@@ -626,6 +643,7 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         }
         const duration = Date.now() - startTime;
         // --- Format result ---
+        const runDoneAtMs = Date.now();
         const nodes = finalExecution.nodeExecutions ?? [];
         // subworkflow.run carries an inline base64 screenshot on some graph shapes;
         // only used for the image block below.
@@ -729,13 +747,26 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         };
         if (verdict.budget)
             responsePayload.budget = verdict.budget;
+        // Bead w1os.1: say where the wall-clock went. setupMs is everything this MCP
+        // did before queuing the run (tunnel, route lock, health probe); runMs is
+        // queue-to-terminal on the backend (agent loop, incl. sign-in). Measured,
+        // not estimated.
+        if (execStartedAtMs !== undefined) {
+            responsePayload.timings = {
+                setupMs: execStartedAtMs - startTime,
+                runMs: runDoneAtMs - execStartedAtMs,
+                totalMs: Date.now() - startTime,
+            };
+        }
         // For "navigate and describe what you see", the answer IS the deliverable —
         // and it reached callers only incidentally, buried in actionTrace[0].intent,
         // which the verify-gate rewrites when it disagrees with the page. Surface it.
         if (verdict.report)
             responsePayload.report = verdict.report;
-        if (verdict.logins)
+        if (verdict.logins) {
             responsePayload.logins = verdict.logins;
+            responsePayload.loginSummary = summarizeLogins(verdict.logins);
+        }
         if (verdict.loginError)
             responsePayload.loginError = verdict.loginError;
         // Bead b5x6: the caller named an account and the run SUBMITTED an
@@ -801,7 +832,9 @@ async function testPageChangesHandlerInner(input, context, rawProgressCallback)
         // browser_session block: presigned S3 URLs for HAR + console log + recording,
         // passed through verbatim.
         if (finalExecution.browserSession) {
-            responsePayload.browserSession = finalExecution.browserSession;
+            // Bead w1os.3: artifacts are uploaded after the terminal state; re-read
+            // briefly while the backend says they are still queued.
+            responsePayload.browserSession = await refreshPendingArtifacts((id) => client.workflows.getExecution(id), executionUuid, finalExecution.browserSession) ?? finalExecution.browserSession;
         }
         logger.toolComplete('check_app_in_browser', duration);
         // NOTE (bead 0bq): the final "Complete:" progress is emitted INSIDE

package/dist/services/caddy/caddyProxy.js

@@ -222,6 +222,84 @@ export const CADDY_HANDLER_ID = 'dbg-handler';
 /** Placeholder upstream: dials a closed port so a stray request 502s cleanly
  *  from the first millisecond instead of exposing a raw connection-refused. */
 const PLACEHOLDER_DIAL = '127.0.0.1:1';
+/** Path prefix under which a secondary local origin is exposed on the tunnel. */
+export const AUX_PATH_PREFIX = '/__o';
+/** @id of the subroute holding the per-origin routes. */
+export const CADDY_AUX_ID = 'dbg-aux';
+const LOCAL_HOST_ALIASES = '(?:localhost|127\\.0\\.0\\.1|host\\.docker\\.internal|\\[::1\\])';
+/**
+ * Location-header rewrite rules: a redirect to any local alias of a known port
+ * becomes a path on the tunnel origin, so the REMOTE browser (which cannot
+ * resolve `host.docker.internal` / dial its own `localhost:PORT`) follows it
+ * through the tunnel. The primary port maps to `/`, an aux port to `/__o/<port>/`.
+ */
+export function buildLocationRewrites(primaryPort, aux) {
+    const rules = [];
+    for (const o of aux) {
+        rules.push({
+            search_regexp: `^https?://${LOCAL_HOST_ALIASES}:${o.port}(?:/(.*))?$`,
+            replace: AUX_PATH_PREFIX + '/' + o.port + '/${1}',
+        });
+    }
+    if (primaryPort !== undefined) {
+        rules.push({
+            search_regexp: `^https?://${LOCAL_HOST_ALIASES}:${primaryPort}(?:/(.*))?$`,
+            // Once any aux origin exists the primary is addressed by prefix too, so a
+            // redirect BACK to it does not inherit an aux page's Referer-scoped routing.
+            replace: AUX_PATH_PREFIX + '/' + primaryPort + '/${1}',
+        });
+    }
+    return rules;
+}
+function withLocationRewrites(handler, rules) {
+    if (rules.length === 0)
+        return handler;
+    return { ...handler, headers: { response: { replace: { Location: rules } } } };
+}
+/**
+ * The subroute that serves every authorised origin (aux origins plus the
+ * current primary), each addressable two ways:
+ *  - `/__o/<port>/*`  -> prefix stripped, proxied to that port;
+ *  - any other path whose Referer is a `/__o/<port>/` page -> proxied to that
+ *    port UNstripped, so root-relative links, form actions and assets on a
+ *    secondary origin's page stay on that origin. The per-origin routes are
+ *    fixed at config time, so a forged Referer can only select an origin the
+ *    caller already authorised.
+ * A request matching neither falls through to the primary upstream.
+ */
+export function buildAuxSubroute(aux, primary, inDocker) {
+    const rules = buildLocationRewrites(primary?.port, aux);
+    const all = [...aux];
+    if (primary && aux.length > 0 && !all.some((o) => o.port === primary.port)) {
+        all.push({ port: primary.port, isHttpsLocal: primary.isHttpsLocal });
+    }
+    const proxyFor = (o) => {
+        const proxy = {
+            handler: 'reverse_proxy',
+            upstreams: [{ dial: resolveDialAddress(o.port, !!o.isHttpsLocal, inDocker) }],
+        };
+        if (o.isHttpsLocal)
+            proxy.transport = { protocol: 'http', tls: { insecure_skip_verify: true } };
+        return withLocationRewrites(proxy, rules);
+    };
+    const routes = [];
+    for (const o of all) {
+        routes.push({
+            match: [{ path: [`${AUX_PATH_PREFIX}/${o.port}/*`] }],
+            handle: [{ handler: 'rewrite', strip_path_prefix: `${AUX_PATH_PREFIX}/${o.port}` }, proxyFor(o)],
+        });
+    }
+    for (const o of all) {
+        routes.push({
+            match: [{
+                    not: [{ path: [`${AUX_PATH_PREFIX}/*`] }],
+                    header_regexp: { Referer: { pattern: `^https?://[^/]+${AUX_PATH_PREFIX}/${o.port}/` } },
+                }],
+            handle: [proxyFor(o)],
+        });
+    }
+    return { '@id': CADDY_AUX_ID, handler: 'subroute', routes };
+}
 /**
  * Builds the eager-at-spawn Caddy JSON config. One code path for every call
  * including the first (architecture doc §2.2): PATCH-only against a known
@@ -229,7 +307,7 @@ const PLACEHOLDER_DIAL = '127.0.0.1:1';
  * building new structure. Both listeners bind 127.0.0.1 only — the admin
  * API has no built-in auth, so this is a hard security requirement.
  */
-export function buildCaddyConfig(proxyPort, adminPort) {
+export function buildCaddyConfig(proxyPort, adminPort, aux = []) {
     return {
         admin: { listen: `127.0.0.1:${adminPort}` },
         apps: {
@@ -238,6 +316,10 @@ export function buildCaddyConfig(proxyPort, adminPort) {
                     srv0: {
                         listen: [`127.0.0.1:${proxyPort}`],
                         routes: [
+                            // Aux origins first so `/__o/<port>/*` never falls through to the primary upstream.
+                            {
+                                handle: [buildAuxSubroute(aux, undefined, isDockerEnv())],
+                            },
                             {
                                 handle: [
                                     {
@@ -265,7 +347,7 @@ export function buildCaddyConfig(proxyPort, adminPort) {
  * address, so an omitted `@id` deletes the tag and the NEXT PATCH 404s
  * (only manifests on the second call — see LIFE-4 in the test suite).
  */
-export function buildPatchBody(target, inDocker) {
+export function buildPatchBody(target, inDocker, aux = []) {
     const isHttpsLocal = !!target.isHttpsLocal;
     const dial = resolveDialAddress(target.port, isHttpsLocal, inDocker);
     const body = {
@@ -277,7 +359,8 @@ export function buildPatchBody(target, inDocker) {
         // Local self-signed certs — doesn't touch the public leg's real TLS.
         body.transport = { protocol: 'http', tls: { insecure_skip_verify: true } };
     }
-    return body;
+    // Redirects to the primary origin or an authorised aux origin stay on the tunnel.
+    return aux.length > 0 ? withLocationRewrites(body, buildLocationRewrites(target.port, aux)) : body;
 }
 function adminHttpRequest(adminPort, method, reqPath, body, timeoutMs = 2000) {
     return new Promise((resolve, reject) => {
@@ -325,6 +408,8 @@ export class CaddyProxyManager {
     configPath = null;
     lastProxyPort = null;
     lastAppliedTarget = null;
+    /** Authorised secondary origins (bead w1os.2). Grow-only; survives a respawn. */
+    auxOrigins = [];
     portChangedListeners = [];
     constructor(opts = {}) {
         // Short random hex suffix — PID alone collides once one process hosts
@@ -359,7 +444,7 @@ export class CaddyProxyManager {
             this.lastAppliedTarget.isHttpsLocal === isHttpsLocal) {
             return; // idempotent no-op — this is what makes same-port calls free
         }
-        const body = buildPatchBody(target, isDockerEnv());
+        const body = buildPatchBody(target, isDockerEnv(), this.auxOrigins);
         try {
             await this.patchHandler(adminPort, body);
         }
@@ -379,6 +464,33 @@ export class CaddyProxyManager {
             await this.patchHandler(freshAdminPort, body);
         }
         this.lastAppliedTarget = { port: target.port, isHttpsLocal };
+        if (this.auxOrigins.length > 0)
+            await this.patchAux(this.lastAppliedTarget);
+    }
+    /** Re-issue the aux subroute so it knows the current primary (bead w1os.2). */
+    async patchAux(primary, origins = this.auxOrigins) {
+        const adminPort = this.adminPort;
+        if (adminPort === null)
+            return;
+        const res = await adminHttpRequest(adminPort, 'PATCH', `/id/${CADDY_AUX_ID}`, JSON.stringify(buildAuxSubroute(origins, primary, isDockerEnv())));
+        if (res.status < 200 || res.status >= 300) {
+            throw new CaddyAdminApiError(`PATCH /id/${CADDY_AUX_ID} failed: ${res.status} ${res.body}`);
+        }
+    }
+    async addAuxOrigins(origins) {
+        const fresh = origins.filter((o) => !this.auxOrigins.some((a) => a.port === o.port && !!a.isHttpsLocal === !!o.isHttpsLocal));
+        if (fresh.length === 0)
+            return;
+        const { adminPort } = await this.ensureStarted();
+        const next = [...this.auxOrigins, ...fresh];
+        const primary = this.lastAppliedTarget;
+        // Replace the aux subroute, then re-issue the primary handler so its
+        // Location rewrites know the new origins. Both are idempotent PATCHes.
+        await this.patchAux(primary ?? undefined, next);
+        this.auxOrigins = next;
+        if (primary) {
+            await this.patchHandler(adminPort, buildPatchBody(primary, isDockerEnv(), next));
+        }
     }
     async isHealthy() {
         if (!this.started || !this.adminPort || this.isChildDead)
@@ -445,7 +557,7 @@ export class CaddyProxyManager {
     writeConfig(proxyPort, adminPort) {
         fs.mkdirSync(this.configDir, { recursive: true });
         const configPath = path.join(this.configDir, configFileName(process.pid, this.instanceId));
-        const config = buildCaddyConfig(proxyPort, adminPort);
+        const config = buildCaddyConfig(proxyPort, adminPort, this.auxOrigins);
         fs.writeFileSync(configPath, JSON.stringify(config));
         return configPath;
     }

package/dist/services/verdictAdapter.js

@@ -120,6 +120,23 @@ export function pollTimeoutReason(facts) {
     const head = parts.join(' ');
     return facts.lastStatus ? `${head}; last status: ${facts.lastStatus}.` : `${head}.`;
 }
+/**
+ * Counts over the login records (bead w1os.4) — numbers only, so the MCP
+ * authors no text (epic 56kd). The backend appends a `no_login_form_detected`
+ * record (submitted:false, authenticated:false) after a successful sign-in
+ * whenever a later page had no form; read alone it looks like a failed login.
+ * The raw records stay verbatim (bead ymq2); this just states the tally:
+ *   authenticated — records with authenticated:true
+ *   failed        — typed credentials (submitted:true) and did not authenticate
+ *   notAttempted  — nothing was typed (skipped or refused records)
+ */
+export function summarizeLogins(logins) {
+    if (!logins)
+        return undefined;
+    const authenticated = logins.filter((l) => l.authenticated === true).length;
+    const failed = logins.filter((l) => l.authenticated !== true && l.submitted === true).length;
+    return { total: logins.length, authenticated, failed, notAttempted: logins.length - authenticated - failed };
+}
 /** Credential sources that mean "the caller named this account for this run". */
 const CALLER_SPECIFIED_SOURCES = new Set(['task', 'explicit', 'credential_id']);
 /**

package/dist/tools/testPageChanges.js

@@ -106,6 +106,12 @@ export function buildTestPageChangesTool(ctx) {
                     type: "boolean",
                     description: "Default false. Set true to force a REAL login instead of reusing the warm session the backend keeps per account. Use when the login flow itself is what you're checking, when you suspect the stored session is stale, or when the app's only route between personas is a logout. Costs one login; the run re-captures afterwards, so later runs stay fast."
                 },
+                extraOrigins: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Extra LOCAL origins this run may be redirected to, e.g. [\"http://host.docker.internal:4717\", \"http://localhost:4304\"] (a bare port like \"4304\" also works). Use for flows that hop between local servers — an OAuth consent page on another port, a callback on a third — which the remote browser otherwise cannot reach (DNS_PROBE_FINISHED_NXDOMAIN / connection refused). Redirects to these origins, and to the main url's origin, are followed through the tunnel; only origins listed here are exposed. Hosts allowed: localhost, 127.0.0.1, [::1], host.docker.internal. Limitation: absolute URLs written inside page HTML (not redirects) are not rewritten.",
+                    maxItems: 8
+                },
                 repoName: {
                     type: "string",
                     description: "GitHub repository name (e.g. 'my-org/my-repo'). Auto-detected from the current git repo — only provide this if you want to run against a different project than the one you're in."

package/dist/types/index.js

@@ -64,6 +64,11 @@ export const TestPageChangesInputSchema = z.object({
     // skip login; that is right for speed and wrong when the login itself is what
     // you are checking, or when the app's only route between personas is a logout.
     freshSession: z.boolean().optional(),
+    // Extra LOCAL origins the run may be redirected to (bead w1os.2) — e.g. an OAuth
+    // vendor on :4717 (also host.docker.internal:4717) or a callback on :4304. Each is
+    // tunnelled and redirects to it are followed through the tunnel. Only origins named
+    // here are exposed.
+    extraOrigins: z.array(z.string().min(1)).max(8, 'extraOrigins accepts at most 8 origins.').optional(),
     // Auth-precondition deep-link intent (bead 56kd.6) — "log in THEN go to X".
     auth: AuthPreconditionSchema.optional(),
 });

package/dist/utils/artifactGrace.js

@@ -0,0 +1,29 @@
+const PENDING = /queue|pending|processing|uploading|downloading/i;
+export function artifactsPending(bs) {
+    if (!bs)
+        return false;
+    const statuses = [bs.recordingStatus, bs.harStatus, bs.consoleLogStatus];
+    return statuses.some((s) => typeof s === 'string' && PENDING.test(s));
+}
+function artifactsReady(bs) {
+    return !artifactsPending(bs) || (!!bs.harUrl && !!bs.consoleLogUrl);
+}
+export async function refreshPendingArtifacts(getExecution, executionUuid, current, opts = {}) {
+    const attempts = opts.attempts ?? 3;
+    const intervalMs = opts.intervalMs ?? 2000;
+    let latest = current;
+    for (let i = 0; i < attempts && artifactsPending(latest) && !(latest && artifactsReady(latest)); i++) {
+        if (opts.signal?.aborted)
+            break;
+        await new Promise((r) => setTimeout(r, intervalMs));
+        try {
+            const exec = await getExecution(executionUuid);
+            if (exec.browserSession)
+                latest = exec.browserSession;
+        }
+        catch {
+            break; // artifact refresh is best-effort; never fail the run for it
+        }
+    }
+    return latest;
+}

package/dist/utils/extraOrigins.js

@@ -0,0 +1,57 @@
+/**
+ * Extra local origins a run may be redirected to (bead w1os.2). Kept out of
+ * tunnelContext.ts so handler tests that mock that module are unaffected.
+ */
+import { tunnelManager } from '../services/tunnel/tunnelManager.js';
+import { extractLocalhostPort } from './urlParser.js';
+const EXTRA_ORIGIN_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]', '::1', 'host.docker.internal']);
+export class ExtraOriginError extends Error {
+    origin;
+    constructor(origin, reason) {
+        super(`extraOrigins entry "${origin}" ${reason}`);
+        this.origin = origin;
+        this.name = 'ExtraOriginError';
+    }
+}
+/** Parse `4304`, `localhost:4304`, or `http(s)://host.docker.internal:4717[/…]`. */
+export function parseExtraOrigin(raw) {
+    const t = raw.trim();
+    if (/^\d+$/.test(t)) {
+        const port = Number(t);
+        if (port < 1 || port > 65535)
+            throw new ExtraOriginError(raw, 'is not a valid port');
+        return { port };
+    }
+    let u;
+    try {
+        u = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(t) ? t : `http://${t}`);
+    }
+    catch {
+        throw new ExtraOriginError(raw, 'is not a URL, host:port, or port');
+    }
+    if (u.protocol !== 'http:' && u.protocol !== 'https:')
+        throw new ExtraOriginError(raw, 'must be http or https');
+    if (!EXTRA_ORIGIN_HOSTS.has(u.hostname.toLowerCase())) {
+        throw new ExtraOriginError(raw, 'must be localhost, 127.0.0.1, [::1] or host.docker.internal');
+    }
+    const isHttpsLocal = u.protocol === 'https:';
+    const port = u.port ? Number(u.port) : isHttpsLocal ? 443 : 80;
+    return { port, ...(isHttpsLocal ? { isHttpsLocal: true } : {}) };
+}
+/**
+ * Authorise the caller's extra origins on this session's Caddy and record them
+ * on the context. Call after `acquirePortRoute`. No-op without a tunnel.
+ */
+export async function authorizeExtraOrigins(ctx, raw) {
+    if (!raw || raw.length === 0 || !ctx.isLocalhost || !ctx.tunnelId)
+        return ctx;
+    const primaryPort = extractLocalhostPort(ctx.originalUrl);
+    const origins = raw.map(parseExtraOrigin).filter((o) => o.port !== primaryPort);
+    if (origins.length === 0)
+        return ctx;
+    const info = tunnelManager.getTunnelInfo(ctx.tunnelId);
+    if (!info)
+        throw new Error(`authorizeExtraOrigins: no TunnelInfo for tunnel ${ctx.tunnelId}`);
+    await info.caddy.addAuxOrigins(origins);
+    return { ...ctx, extraOrigins: origins };
+}

package/dist/utils/localReachability.js

@@ -101,10 +101,13 @@ export async function probeTunnelHealth(tunnelUrl, opts = {}) {
     const timeoutMs = opts.timeoutMs ?? 5000;
     const started = Date.now();
     let last;
+    let allClosed = true;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         const { result, retryable } = await probeOverControlChannel(tunnelUrl, timeoutMs, started);
         if (!retryable)
             return result;
+        if (!result.detail?.endsWith(' CLOSED'))
+            allClosed = false;
         last = result;
         if (attempt < maxAttempts) {
             await sleep(backoff[attempt - 1] ?? backoff[backoff.length - 1] ?? 150);
@@ -112,6 +115,14 @@ export async function probeTunnelHealth(tunnelUrl, opts = {}) {
     }
     // Ladder exhausted on a transient error — the tunnel never came up. Report
     // it: "not ready" that never becomes ready IS unhealthy.
+    //
+    // A control channel CLOSED on every attempt means the tunnel has no live
+    // session at all (a reconnect that never lands, or the transport forgot the
+    // tunnel while the manager still holds it). It can never serve a request, so
+    // flag it for eviction — otherwise every later call reuses the corpse and
+    // fails identically until the MCP process restarts.
+    if (allClosed && last)
+        last.tunnelErrorCode = 'CONTROL_CHANNEL_CLOSED';
     return last;
 }
 // ─ Control-channel probe ─────────────────────────────────────────────────────

package/dist/utils/tunnelContext.js

@@ -9,6 +9,7 @@
  */
 import { tunnelManager, getSessionKey } from '../services/tunnel/tunnelManager.js';
 import { isLocalhostUrl, replaceTunnelUrls, retargetTunnelUrl, extractLocalhostPort } from './urlParser.js';
+import { AUX_PATH_PREFIX } from '../services/caddy/caddyProxy.js';
 // ─── URL resolution ──────────────────────────────────────────────────────────
 /**
  * Resolve tool input to a concrete URL string.
@@ -110,6 +111,12 @@ export function retargetAuxiliaryUrl(ctx, auxUrl) {
     const port = extractLocalhostPort(auxUrl);
     const primaryPort = extractLocalhostPort(ctx.originalUrl);
     if (port !== undefined && primaryPort !== undefined && port !== primaryPort) {
+        // Bead w1os.2: a port the caller authorised via extraOrigins is reachable at /__o/<port>/.
+        if (ctx.extraOrigins?.some((o) => o.port === port)) {
+            const t = new URL(auxUrl);
+            const base = new URL(ctx.targetUrl);
+            return { ok: true, url: `${base.origin}${AUX_PATH_PREFIX}/${port}${t.pathname}${t.search}${t.hash}`, rewritten: true };
+        }
         return { ok: false, reason: 'port_mismatch', port, primaryPort };
     }
     return { ok: true, url: retargetTunnelUrl(ctx.targetUrl, auxUrl), rewritten: true };

package/dist/utils/tunnelDisposition.js

@@ -69,6 +69,11 @@ const logger = new Logger({ module: 'tunnelDisposition' });
 const ENDPOINT_GONE_CODES = Object.freeze([
     'DEBUGG_TUNNEL_OFFLINE',
     'DEBUGG_TUNNEL_UNKNOWN',
+    // Client-side verdict, not a server marker: probeTunnelHealth saw the tunnel's
+    // own control channel CLOSED on every attempt of its ladder, i.e. there is no
+    // session left to carry traffic. Keeping it makes every later call fail the
+    // same way (the crochets build lead's "stuck at CLOSED" report).
+    'CONTROL_CHANNEL_CLOSED',
 ]);
 const ENDPOINT_GONE_LOOKUP = new Set(ENDPOINT_GONE_CODES);
 /** The allowlist, as an immutable list. Read-only by construction. */

package/package.json

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