@ait-co/devtools 0.1.144 → 0.2.1

package/dist/debug-server-CfQNxxGW.js

@@ -1,600 +0,0 @@
-import { a as ChiiCdpConnection, o as RELAY_AUTH_REJECT_CLOSE_CODE, s as RELAY_AUTH_REJECT_REASON } from "./relay-worker-B5HKkGUY.js";
-import { c as generateAttachToken, d as startQuickTunnel, f as startTunnelHealthProbe, l as makeTunnelStatus, m as logInfo, p as logError, u as printAttachBanner } from "./attach-orchestrator-0F0m_UqQ.js";
-import { n as buildRelayVerifyAuth, t as assertRelayAuthConfigured } from "./totp-DAxys-r0.js";
-import "./cell-CBUS3-nT.js";
-import "./relay-factory-N9QobQxG.js";
-import "./qr-http-server-CopuMbub.js";
-import "./relay-secret-store-WJ8EGkIl.js";
-import { createRequire } from "node:module";
-import "node:events";
-import { WebSocketServer } from "ws";
-import "@modelcontextprotocol/sdk/server/index.js";
-import "@modelcontextprotocol/sdk/server/stdio.js";
-import "@modelcontextprotocol/sdk/types.js";
-import { createServer } from "node:http";
-`
-devtools-test — run mini-app tests on a real device WebView over the CDP relay
-
-USAGE
-  devtools-test <glob> [<glob> ...] [options]
-
-OPTIONS
-  --scheme-url <url>      intoss-private:// URL from \`ait deploy --scheme-only\`
-                          (required for standalone relay attach / env3). Unused
-                          and ignored when --attach-launcher is set.
-  --attach-launcher       Attach over the env-2 AITC Sandbox PWA launcher
-                          (real-device WebKit) instead of the env-3 intoss
-                          scheme deep-link. The relay/QR/dashboard/attach-wait
-                          are identical; only the QR is a launcher deep-link.
-                          Requires --app-url. The SDK still hits the mock in
-                          env 2, so this measures the mock + standard Web API
-                          layer's engine-attributable behavior (env1↔env2
-                          equivalence), NOT native-bridge fidelity (that is env3).
-  --app-url <url>         The consumer dev server's HTTP tunnel URL (e.g. the
-                          *.trycloudflare.com URL from \`pnpm dev:phone:cdp\`)
-                          that the launcher PWA frames. REQUIRED with
-                          --attach-launcher; ignored otherwise. SECRET: a tunnel
-                          host — never printed; it rides only inside the QR.
-  --timeout <ms>          Per-file evaluate timeout in ms (default: 60000).
-                          Controls how long a single test file is allowed to run
-                          before it is considered hung. Does NOT affect how long
-                          the CLI waits for a human to scan the QR code — use
-                          --attach-timeout for that.
-  --attach-timeout <ms>   How long to wait for a human to scan the QR code with
-                          their phone. Omit (default) to wait indefinitely — the
-                          runner stays up until you stop it (Ctrl-C/SIGTERM).
-                          Pass a value to bound the wait for CI/headless runs.
-  --cell-sdk-line <line>  SDK line to inject as __AIT_CELL__.sdkLine (2.x|3.x)
-  --cell-platform <plat>  Platform to inject as __AIT_CELL__.platform
-                          (mock|ios|android|ios-pwa, default: AIT_CELL_PLATFORM
-                          env). Use ios-pwa for env-2 (--attach-launcher) runs
-                          so env1(mock@desktop) and env2(mock@WebKit) captures
-                          stay distinguishable. An unknown value is rejected.
-  --report-dir <dir>      Persist a runner-agnostic report + captures to <dir>
-                          (report: <sdkLine>.<platform>.json; captures:
-                          <dir>/.ait-capture/<category>.<sdkLine>.<platform>.json).
-                          Omitted = nothing saved. Enables console capture.
-  --dashboard-port <port> Base port for the QR dashboard HTTP server. On
-                          EADDRINUSE it increments (+1, up to 20 tries) before
-                          falling back to an ephemeral port. Omit to use
-                          AIT_DEBUG_HTTP_PORT env or the built-in default
-                          (8317) — pass 0 to force a random ephemeral port.
-  --no-qr-stdout          Suppress the QR/attach block on stdout (auto-on for
-                          non-interactive stdout / CI / AIT_NO_QR_STDOUT)
-  --headless              Disable browser auto-open (text QR only)
-  --project-root <dir>    Project root for .ait_relay secret lookup
-                          (default: current working directory)
-  --pace <ms>             Minimum delay in ms between test-to-test AND
-                          file-to-file bridge calls (default: 0, i.e. no
-                          added delay — today's behavior byte-for-byte).
-                          Falls back to the AIT_PACE env var when omitted
-                          (--pace takes precedence over the env var when both
-                          are given). Use on a 2.x cell scan when the native
-                          per-method bridge rate limit (APP_BRIDGE_THROTTLED,
-                          devtools#767) is rejecting rapid same-method calls —
-                          3.x cells are unaffected by that limiter and do not
-                          need this flag.
-  --pace-method <ms>      Minimum delay in ms BETWEEN calls to the SAME named
-                          SDK function — paces a same-method burst WITHIN a
-                          single test body (e.g. a clipboard happy-path loop
-                          calling setClipboardText/getClipboardText 8 times
-                          back to back), which --pace's test/file spacing
-                          cannot reach (devtools#769). Falls back to the
-                          AIT_PACE_METHOD env var when omitted (--pace-method
-                          takes precedence over the env var when both are
-                          given). Default: 250ms when --cell-sdk-line is 2.x
-                          (unset --cell-sdk-line also defaults to 2.x — see
-                          --cell-sdk-line), 0 (no added delay) otherwise. Pass
-                          --pace-method 0 to opt out even on a 2.x cell.
-  --manual-blocking       Run manual-tagged test files (*.manual.ait.test.ts)
-                          LAST, after all regular files, with a human present.
-                          Before each manual file, the QR dashboard is pushed
-                          a step-by-step Korean prompt naming the file + its
-                          progress (k/n), and the same line is printed to
-                          stdout. Manual files get a 5-minute per-file evaluate
-                          timeout (vs. --timeout for everything else) since a
-                          human is expected to tap through a native sheet
-                          (photo picker, permission dialog, fullscreen ad).
-                          Without this flag (default off), *.manual.ait.test.ts
-                          files are EXCLUDED from the glob expansion entirely —
-                          existing unattended runs are byte-for-byte unaffected.
-                          With --report-dir, a run that included manual files
-                          ALSO writes <sdkLine>.<platform>.manual.json
-                          alongside (never replacing) the standard report, and
-                          each manual file's report entry is stamped
-                          mode: 'manual' — never diff a manual run against an
-                          unattended baseline as if they were equivalent.
-  --stub-blocking         Run manual-tagged test files (*.manual.ait.test.ts)
-                          UNATTENDED (devtools#740, DT-2) by intercepting a
-                          fixed allowlist of blocking-UI SDK calls (ads
-                          show*, openPermissionDialog/requestPermission,
-                          saveBase64Data) in the page and answering them from
-                          fixtures captured by a real --manual-blocking run,
-                          instead of forwarding them to native UI. Implies
-                          --manual-blocking (manual files are included in the
-                          run); no human presence or QR-dashboard prompt is
-                          needed for them. HYBRID cell, not pure env3 — every
-                          other SDK call in the same run still hits the real
-                          native bridge. With --report-dir, files that ran
-                          under the stub are written to a SEPARATE
-                          <sdkLine>.<platform>.stubbed.json artifact (never
-                          merged into the standard or .manual.json report) and
-                          the report body is stamped cell.bridgeStub: true —
-                          never diff a stubbed run against a real device
-                          baseline (manual or unattended) as if equivalent.
-  --help, -h              Show this help message
-
-DESCRIPTION
-  Boots a Chii relay + cloudflared tunnel, renders a QR code, waits for a real
-  device to scan and attach, injects the cell globals (__AIT_CELL__), bundles
-  each matched test file with esbuild (SDK imports redirected to window.__sdk),
-  injects the bundle into the attached WebView via Runtime.evaluate, and prints
-  a summary.
-
-  With --report-dir, also harvests __AIT_CAPTURE__ console lines and writes a
-  runner-agnostic report + per-category capture files so 2.x↔3.0 runs can be
-  compared offline.
-
-  The test files run against the live relay connection started by this process;
-  no separate MCP daemon is required.
-
-EXAMPLE (env 3 — intoss-private scheme)
-  devtools-test 'src/**/*.ait.test.ts' \\
-    --scheme-url "intoss-private://..." \\
-    --cell-sdk-line 3.x \\
-    --cell-platform ios \\
-    --report-dir .ait-report \\
-    --timeout 60000
-
-EXAMPLE (env 2 — AITC Sandbox PWA launcher)
-  devtools-test 'src/**/*.ait.test.ts' \\
-    --attach-launcher \\
-    --app-url "https://<subdomain>.trycloudflare.com" \\
-    --cell-sdk-line 3.x \\
-    --cell-platform ios-pwa \\
-    --report-dir .ait-report
-
-`.trimStart();
-//#endregion
-//#region src/mcp/chii-relay.ts
-/**
-* Boots the local Chii relay server.
-*
-* Chii (liriliri/chii) is a chobitsu-based CDP relay that lets non-Chrome
-* WebViews (iOS WKWebView / Android WebView — i.e. the Toss app) expose CDP.
-* The relay accepts a `target` websocket from the phone's injected `target.js`
-* and `client` websockets from CDP frontends (our MCP connection).
-*
-* Node-only: `chii` pulls in Koa + ws. Never bundled into the browser/in-app
-* entries.
-*
-* TOTP auth (relay-side, authoritative gate):
-*   When `verifyAuth` is provided, this module gates both inbound surfaces:
-*
-*   - HTTP 'request': a listener registered BEFORE `chii.start({server})`.
-*     Node's `http.Server` calls listeners in registration order; the first
-*     to call `res.end()` wins. Invalid auth → 401 + CORS header + a tiny
-*     JSON body (`{"error":"totp-rejected"}`) so a cross-origin script
-*     `fetch()` probe can READ the status (issue #478). Valid auth → return
-*     without side-effect (chii's Koa handler serves it).
-*
-*   - WS 'upgrade': after `chii.start()` has registered chii's own upgrade
-*     listener, we take over the upgrade chain (remove chii's listeners,
-*     re-dispatch manually). Invalid auth → accept-then-close: complete the
-*     handshake via a `noServer` WebSocketServer, then immediately close
-*     with code 4401 reason 'totp-rejected' (issue #478). A raw 401 +
-*     `socket.destroy()` only ever surfaced as close code 1006 in the
-*     browser — indistinguishable from a tunnel failure, which left the
-*     env-2 phone UI silent. The explicit dispatch (not listener ordering)
-*     is what keeps chii away from rejected sockets: accept-then-close
-*     leaves the socket alive, so an order-based early-return would let
-*     chii's later listener complete a SECOND handshake on the same socket
-*     — an auth bypass. Valid auth → forward to chii's captured listeners.
-*
-* TOTP code transports (issue #466) — two equivalent ways to carry the code:
-*   1. Query param `at=<code>` — used by the daemon-side `/client` connection
-*      (`chii-connection.ts` appends it; it holds the secret).
-*   2. Path prefix `/at/<code>/…` — used by the phone-side target. Chii's
-*      stock `target.js` derives its WS endpoint from the script `src`
-*      (`scriptEl.src.replace('target.js','')`), so the only way for the
-*      phone to carry a code is to embed it in the script URL path. The
-*      in-app attach injects `https://<host>/at/<code>/target.js`; both the
-*      script fetch and the derived `wss://<host>/at/<code>/target/<id>` WS
-*      dial then carry the prefix. The listeners below rewrite the prefix
-*      into the query form (`rewriteAtPathPrefix`) and MUTATE `req.url`
-*      before chii's own handlers (registered later) parse it — chii only
-*      ever sees the stripped URL.
-*
-* Threat model: "URL leak" — someone obtains the tunnel URL (Slack paste, QR
-*   screenshot, shoulder-surfing) but does not have the shared TOTP secret.
-*   Rotating 6-digit code makes the URL stale after 30 s.
-*   A determined attacker who extracts the secret from the dogfood bundle can
-*   still compute valid codes; that is out of scope (see umbrella CLAUDE.md §4).
-*
-* SECRET-HANDLING: The secret value and computed TOTP codes MUST NOT appear
-*   in any log, error message, or process output. `verifyAuth` is a black-box
-*   predicate from the caller's perspective; this module only forwards pass/fail.
-*/
-const require = createRequire(import.meta.url);
-/**
-* WS keepalive ping interval (ms).
-*
-* Cloudflare proxied connections are dropped after ~100 s of no traffic.
-* 45 s comfortably fits inside that window and lets both the phone-target leg
-* and the daemon-client leg survive idle CDP sessions.
-*/
-const DEFAULT_KEEPALIVE_INTERVAL_MS = 45e3;
-/**
-* Loads chii's internal WebSocketServer class and returns it together with a
-* flag indicating whether the real class was found.
-*
-* Returns `null` if the internal path is not resolvable (future chii release
-* changes the layout) — callers skip keepalive gracefully.
-*/
-function tryLoadChiiWssClass() {
-	try {
-		const mod = require("chii/server/lib/WebSocketServer");
-		if (typeof mod === "function") return mod;
-	} catch {}
-	return null;
-}
-/**
-* Calls `chii.start()` and returns the chii `WebSocketServer` instance that
-* was constructed during the call.
-*
-* How: `chii/server/index.js`'s `start()` creates `new WebSocketServer()`
-* where `WebSocketServer` is captured from `require('./lib/WebSocketServer')`
-* at module load time. The class reference is stable, so we can temporarily
-* patch `ChiiWssClass.prototype.start` — which runs *on the instance* —
-* to record `this` before the original `start` runs.
-*
-* The patch is installed before `chii.start()` and removed (via `finally`)
-* immediately after, so concurrent `startChiiRelay` calls nest correctly: each
-* call's patch overrides the previous in the prototype chain for the duration
-* of its own `chii.start()` call, restoring the prior descriptor on exit.
-*
-* If `ChiiWssClass` is null (internal path changed in a future chii release),
-* `chii.start()` runs unpatched and the function returns null — callers skip
-* keepalive gracefully without affecting relay correctness.
-*/
-async function startChiiWithCapture(chii, startOptions, ChiiWssClass) {
-	if (ChiiWssClass === null) {
-		await chii.start(startOptions);
-		return null;
-	}
-	let captured = null;
-	const proto = ChiiWssClass.prototype;
-	const originalStart = proto.start;
-	proto.start = function(server) {
-		captured = this;
-		return originalStart.call(this, server);
-	};
-	try {
-		await chii.start(startOptions);
-	} finally {
-		proto.start = originalStart;
-	}
-	return captured;
-}
-function loadChiiServer() {
-	const mod = require("chii");
-	if (typeof mod === "object" && mod !== null && "start" in mod && typeof mod.start === "function") return mod;
-	throw new Error("chii server module did not expose start()");
-}
-/**
-* Rewrites a `/at/<code>/…` path-prefixed request URL into the equivalent
-* query-based form, e.g.:
-*
-*   `/at/123456/target.js`        → `/target.js?at=123456`
-*   `/at/123456/target/x?url=u`   → `/target/x?url=u&at=123456`
-*   `/at/123456/`                 → `/?at=123456`
-*
-* Returns `null` when the URL does not carry the prefix (including an empty
-* code segment) — callers fall back to the unmodified URL and the existing
-* query-based auth path.
-*
-* Pure string surgery — this function knows nothing about secrets or code
-* validity; verification stays inside the caller-provided `verifyAuth`
-* predicate (which parses the query). The raw path segment is appended
-* verbatim to the query: both path segments and query values are
-* percent-decoded exactly once by their consumers, so no re-encoding is
-* needed (TOTP codes are 6 digits and never percent-encoded in practice).
-*/
-function rewriteAtPathPrefix(rawUrl) {
-	const match = /^\/at\/([^/?]+)(\/[^?]*)?(\?.*)?$/.exec(rawUrl);
-	if (match === null) return null;
-	const code = match[1];
-	const path = match[2] === void 0 || match[2] === "" ? "/" : match[2];
-	const query = match[3] ?? "";
-	return `${path}${query}${query === "" ? "?" : "&"}at=${code}`;
-}
-/**
-* Starts the Chii relay and resolves once listening.
-*
-* Default port is 0 (OS-assigned). With port 0 the OS picks a free ephemeral
-* port on every start, so a stale cloudflared orphan holding any particular
-* port cannot cause EADDRINUSE. The resolved `ChiiRelay.port` and `baseUrl`
-* always reflect the actual bound port.
-*
-* chii.start() is called with `server` (our pre-created httpServer) BEFORE
-* httpServer.listen(). This is intentional: chii attaches its Koa handler and
-* WS upgrade listener to the server object, but the actual TCP bind is
-* performed by our httpServer.listen() call below. The `port`/`domain` values
-* passed to chii.start() are used for display/banner purposes inside chii and
-* do not affect which port the server binds. The connection path (clients
-* connecting to `relay.baseUrl`) always uses the post-listen confirmed port.
-*/
-async function startChiiRelay(options = {}) {
-	const requestedPort = options.port ?? 0;
-	const host = options.host ?? "127.0.0.1";
-	const { verifyAuth, onAuthReject } = options;
-	const keepaliveIntervalMs = options.keepaliveIntervalMs !== void 0 ? options.keepaliveIntervalMs : DEFAULT_KEEPALIVE_INTERVAL_MS;
-	const httpServer = createServer();
-	const notifyAuthReject = (kind) => {
-		if (onAuthReject === void 0) return;
-		try {
-			onAuthReject({ kind });
-		} catch {}
-	};
-	if (verifyAuth) httpServer.on("request", (req, res) => {
-		const rewritten = rewriteAtPathPrefix(req.url ?? "");
-		if (rewritten !== null) {
-			req.url = rewritten;
-			if (!verifyAuth(req)) {
-				res.statusCode = 401;
-				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({ error: RELAY_AUTH_REJECT_REASON }));
-				notifyAuthReject("http-request");
-			}
-			return;
-		}
-		const pathname = (req.url ?? "").split("?")[0];
-		if (pathname === "/targets" || pathname === "/targets/") {
-			if (!verifyAuth(req)) {
-				res.statusCode = 401;
-				res.setHeader("Access-Control-Allow-Origin", "*");
-				res.setHeader("Content-Type", "application/json");
-				res.end(JSON.stringify({ error: RELAY_AUTH_REJECT_REASON }));
-				notifyAuthReject("http-request");
-				return;
-			}
-			return;
-		}
-	});
-	const chiiWssClass = keepaliveIntervalMs > 0 ? tryLoadChiiWssClass() : null;
-	const capturedChiiWss = await startChiiWithCapture(loadChiiServer(), {
-		server: httpServer,
-		domain: `${host}:${requestedPort}`,
-		port: requestedPort
-	}, chiiWssClass);
-	if (verifyAuth) {
-		const chiiUpgradeListeners = httpServer.listeners("upgrade");
-		httpServer.removeAllListeners("upgrade");
-		const rejectWss = new WebSocketServer({ noServer: true });
-		httpServer.on("upgrade", (req, socket, head) => {
-			const rewritten = rewriteAtPathPrefix(req.url ?? "");
-			if (rewritten !== null) req.url = rewritten;
-			if (!verifyAuth(req)) {
-				rejectWss.handleUpgrade(req, socket, head, (ws) => {
-					ws.close(RELAY_AUTH_REJECT_CLOSE_CODE, RELAY_AUTH_REJECT_REASON);
-				});
-				notifyAuthReject("ws-upgrade");
-				return;
-			}
-			for (const listener of chiiUpgradeListeners) listener(req, socket, head);
-		});
-	}
-	const actualPort = await new Promise((resolve, reject) => {
-		httpServer.once("error", reject);
-		httpServer.listen(requestedPort, host, () => {
-			httpServer.off("error", reject);
-			resolve(httpServer.address().port);
-		});
-	});
-	let keepaliveHandle = null;
-	if (keepaliveIntervalMs > 0 && capturedChiiWss !== null) {
-		const chiiWss = capturedChiiWss;
-		keepaliveHandle = setInterval(() => {
-			for (const client of chiiWss._wss.clients) if (client.readyState === 1) client.ping();
-		}, keepaliveIntervalMs);
-	}
-	return {
-		port: actualPort,
-		baseUrl: `http://${host}:${actualPort}`,
-		close: () => new Promise((resolve) => {
-			if (keepaliveHandle !== null) {
-				clearInterval(keepaliveHandle);
-				keepaliveHandle = null;
-			}
-			if (capturedChiiWss !== null) for (const client of capturedChiiWss._wss.clients) client.terminate();
-			httpServer.close(() => resolve());
-		})
-	};
-}
-//#endregion
-//#region src/mcp/debug-server.ts
-/**
-* Starts a polling watcher that detects target-set changes on
-* `connection.listTargets()` and sends a `notifications/tools/list_changed`
-* notification on the given server.
-*
-* The watcher polls every `intervalMs` (default 1 000 ms). On each tick it
-* calls `connection.refreshTargets?.()` first (fix #705-B) so that silent
-* disconnects (no CDP event, phone backgrounded / tunnel quiet) are picked up
-* before the signature is read. If `refreshTargets` throws — e.g. a transient
-* relay error — the tick is skipped entirely to avoid a spurious detach signal.
-*
-* After the refresh, it fires `server.sendToolListChanged()` + `onAttach()`
-* whenever the sorted target-id signature changes AND the new target set is
-* non-empty. This covers:
-*   - 0→N first attach
-*   - 1→1 target replacement (same count, different id — e.g. rescan)
-*   - N→M any change where the result is still non-empty
-*
-* Full detach (→ empty) fires `onDetach()` (fix #705-A) on the exact
-* non-empty→empty edge — i.e. only when the previous signature was non-empty.
-* This lets callers push an immediate "disconnected" SSE update to the
-* dashboard without waiting for the next periodic interval.
-*
-* The interval is **never cleared automatically** — it keeps running until
-* `stop()` is called during shutdown. This ensures that a target replacement
-* after the first attach is always detected.
-*
-* `onAttach` is called on every non-empty signature change (or immediately when
-* already attached). Use this to trigger side-effects such as pushing a fresh
-* SSE state to open dashboard tabs (issue #509). Both callbacks are optional;
-* omitting them preserves the previous behaviour exactly.
-*
-* SECRET-HANDLING: target `id`/`title`/`url` are not written to any log here.
-* Only an attach-detected stderr line is emitted (no target details).
-*
-* `server` is optional (devtools#772): the standalone test-runner path
-* (`test-runner/relay-factory.ts`) has no MCP `Server` instance to notify —
-* it only needs the `onAttach`/`onDetach` dashboard-push side effects. When
-* omitted, `sendToolListChanged()` is simply skipped; the signature-diff and
-* callback logic is byte-for-byte the same. Existing MCP daemon call sites
-* always pass a real `Server`, so their behavior is unchanged.
-*
-* @returns `stop` — call this during shutdown to clear the interval.
-*/
-function startAttachWatcher(connection, server, intervalMs = 1e3, onAttach, onDetach) {
-	/** Sorted, comma-joined target-id string — '' means no targets attached. */
-	function signature() {
-		return connection.listTargets().map((t) => t.id).sort().join(",");
-	}
-	let lastSignature = signature();
-	if (lastSignature !== "") {
-		server?.sendToolListChanged();
-		onAttach?.();
-	}
-	/** Compare current vs last signature and fire the appropriate callback. */
-	function tick() {
-		const current = signature();
-		if (current !== lastSignature) {
-			const wasNonEmpty = lastSignature !== "";
-			lastSignature = current;
-			if (current !== "") {
-				server?.sendToolListChanged();
-				onAttach?.();
-			} else if (wasNonEmpty) onDetach?.();
-		}
-	}
-	const handle = setInterval(() => {
-		if (connection.refreshTargets) connection.refreshTargets().then(() => {
-			tick();
-		}, (_err) => {});
-		else tick();
-	}, intervalMs);
-	return { stop() {
-		clearInterval(handle);
-	} };
-}
-/**
-* Factory that constructs a `ChiiCdpConnection` for the given relay base URL.
-*
-* Introduced as a named seam so PR-2 (dual-connection, #348) can defer
-* construction to first-activation time by moving or replacing this call. Since
-* #396 every family (relay included) is constructed lazily on its first
-* `start_debug`, so this is always called from the lazy boot path.
-*
-* The relay base URL is only available after `startChiiRelay()` resolves, so
-* the factory is called right after that point (same as before this refactor).
-*/
-function createRelayConnection(relayBaseUrl) {
-	return new ChiiCdpConnection({
-		relayBaseUrl,
-		totpSecret: process.env.AIT_DEBUG_TOTP_SECRET
-	});
-}
-/**
-* Boots the relay family (issues #348, #356): starts the Chii relay on an
-* OS-assigned port (with optional TOTP gate), opens a cloudflared quick tunnel
-* to the relay's confirmed port in the background, prints the attach banner,
-* and arms the tunnel health probe. Returns a {@link BootedFamily} whose
-* `getTunnelStatus()` reflects the live tunnel (it flips up once the background
-* tunnel resolves and follows reissues).
-*
-* Booted lazily via the dual router's `bootLazyFor('relay-intoss')` callback
-* (symmetry with {@link bootLocalFamily}), at most once on the first
-* `start_debug({ mode: 'relay-staging' })` (all-lazy, #396 — every relay boot now
-* flows through `switchMode` after the project-local secret load). `relay-live`
-* removed (#665).
-*
-* The relay base URL is only known after `startChiiRelay()` resolves, so the
-* `ChiiCdpConnection` (via {@link createRelayConnection}) is constructed inside
-* this function, after the relay port is confirmed.
-*
-* SECRET-HANDLING: the TOTP secret rides only inside `verifyAuth`; the wssUrl
-* (relay host) is never logged here directly.
-*/
-async function bootRelayFamily(options = {}) {
-	assertRelayAuthConfigured();
-	const relayPort = options.relayPort ?? 0;
-	const totpEnabled = options.verifyAuth !== void 0;
-	const relay = await startChiiRelay({
-		port: relayPort,
-		verifyAuth: options.verifyAuth,
-		onAuthReject: options.onAuthReject
-	});
-	logInfo("server.start", {
-		port: relay.port,
-		totpEnabled
-	});
-	let tunnel = null;
-	let tunnelStatus = makeTunnelStatus(false, null);
-	let tunnelProbe = null;
-	generateAttachToken();
-	startQuickTunnel(relay.port).then((t) => {
-		tunnel = t;
-		tunnelStatus = makeTunnelStatus(true, t.wssUrl);
-		options.onWssUrl?.(t.wssUrl);
-		if (t.childPid !== void 0) options.onTunnelChildPid?.(t.childPid);
-		logInfo("tunnel.up", { totpEnabled });
-		tunnelProbe = startTunnelHealthProbe(t, relay.port, {
-			onReissue: (newTunnel) => {
-				tunnel = newTunnel;
-				tunnelStatus = makeTunnelStatus(true, newTunnel.wssUrl, null, 0);
-				options.onWssUrl?.(newTunnel.wssUrl);
-				if (newTunnel.childPid !== void 0) options.onTunnelChildPid?.(newTunnel.childPid);
-				printAttachBanner({
-					wssUrl: newTunnel.wssUrl,
-					totpEnabled
-				}).then(() => {
-					logInfo("tunnel.up", {
-						totpEnabled,
-						reissued: true
-					});
-				});
-			},
-			onPermanentDrop: (droppedAt) => {
-				tunnelStatus = makeTunnelStatus(false, null, droppedAt, 3);
-				logError("tunnel.down", { msg: `tunnel permanently dropped (${droppedAt}). Restart: npx @ait-co/devtools devtools-mcp` });
-				options.onTunnelDown?.();
-			}
-		});
-		return printAttachBanner({
-			wssUrl: t.wssUrl,
-			totpEnabled
-		});
-	}, (err) => {
-		logError("tunnel.down", { msg: `Failed to open cloudflared quick tunnel: ${err instanceof Error ? err.message : String(err)}. The relay is up locally; attach over the public URL is unavailable until the tunnel starts.` });
-	});
-	const connection = createRelayConnection(relay.baseUrl);
-	return {
-		connection,
-		relayOrigin: "intoss-webview",
-		relayHttpUrl: relay.baseUrl,
-		getTunnelStatus: () => tunnelStatus,
-		stop() {
-			tunnelProbe?.stop();
-			tunnel?.stop();
-			connection.close();
-			relay.close();
-		}
-	};
-}
-//#endregion
-export { bootRelayFamily, buildRelayVerifyAuth, startAttachWatcher };
-
-//# sourceMappingURL=debug-server-CfQNxxGW.js.map