@ait-co/devtools 0.1.128 → 0.1.131

package/dist/debug-server-1dhDA3aw.js

@@ -1,980 +0,0 @@
-import { n as buildRelayVerifyAuth, r as generateTotp, t as assertRelayAuthConfigured } from "./totp-DfekTBk3.js";
-import "./test-runner/relay-worker.js";
-import "./relay-factory-Dug7W6Ao.js";
-import { a as startTunnelHealthProbe, i as startQuickTunnel, n as makeTunnelStatus, o as logError, r as printAttachBanner, s as logInfo, t as generateAttachToken } from "./attach-orchestrator-CPMQWkGV.js";
-import "./cell-D0dJSGHi.js";
-import "./qr-http-server-Bo8LMOJQ.js";
-import "./relay-secret-store-DKxs7zwq.js";
-import { createRequire } from "node:module";
-import "@modelcontextprotocol/sdk/server/index.js";
-import "@modelcontextprotocol/sdk/server/stdio.js";
-import "@modelcontextprotocol/sdk/types.js";
-import { EventEmitter } from "node:events";
-import { WebSocket, WebSocketServer } from "ws";
-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)
-  --timeout <ms>          Per-file evaluate timeout in ms (default: 30000).
-                          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 (default: 600000 — 10 minutes). Omit to
-                          use the relay factory's generous default. Decrease for
-                          CI environments where a scan should arrive quickly.
-  --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, default: AIT_CELL_PLATFORM env)
-  --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.
-  --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)
-  --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
-  devtools-test 'src/**/*.ait.test.ts' \\
-    --scheme-url "intoss-private://..." \\
-    --cell-sdk-line 3.x \\
-    --cell-platform ios \\
-    --report-dir .ait-report \\
-    --timeout 60000
-
-`.trimStart();
-//#endregion
-//#region src/shared/relay-auth-close.ts
-/**
-* Shared constants for the relay's named TOTP-auth rejection (issue #478).
-*
-* Before #478 the relay rejected an unauthenticated WebSocket upgrade with a
-* raw `HTTP/1.1 401` + `socket.destroy()`. A handshake aborted that way is
-* indistinguishable from a network failure on the browser side — the
-* WebSocket only ever sees close code 1006, so the phone (env-2 launcher PWA)
-* could not tell "stale TOTP code" apart from "tunnel down" and stayed
-* silent. The fix is accept-then-close: complete the handshake, then close
-* with an application close code that NAMES the rejection.
-*
-* Three parties share this contract:
-*   - `src/mcp/chii-relay.ts` (Node) sends the close frame / HTTP error body;
-*   - `src/in-app/attach.ts` (browser) observes relay-bound WebSockets and
-*     surfaces the code to the launcher shell;
-*   - `src/mcp/chii-connection.ts` (Node daemon client) recognises the code
-*     as an auth failure on its own `/client` dial (defensive — #439's fresh
-*     code mint means it should not normally hit this).
-*
-* This module is intentionally dependency-free (no Node, no DOM) so it is
-* safe to import from both the browser in-app bundle and the MCP daemon
-* bundle.
-*
-* SECRET-HANDLING: these are fixed enum values. The close reason / error body
-* must never grow to carry a secret, a TOTP code, or a host.
-*/
-/**
-* WebSocket close code sent by the relay when TOTP auth is rejected.
-*
-* 4000–4999 is the application-reserved range (RFC 6455 §7.4.2); 4401 mirrors
-* HTTP 401 so it reads as "unauthorized" at a glance.
-*/
-const RELAY_AUTH_REJECT_CLOSE_CODE = 4401;
-/**
-* Close reason string accompanying {@link RELAY_AUTH_REJECT_CLOSE_CODE}, and
-* the `error` value of the relay's HTTP 401 JSON body. Enum string only —
-* never interpolated with request data.
-*/
-const RELAY_AUTH_REJECT_REASON = "totp-rejected";
-//#endregion
-//#region src/mcp/chii-connection.ts
-/**
-* Production `CdpConnection` backed by the local Chii relay.
-*
-* Topology (debug mode):
-*   phone target.js  --WS-->  Chii relay :9100  <--WS--  this connection
-*
-* The phone connects to the relay as a `target`; this module connects as a
-* `client` (the role a CDP frontend would take) so CDP events the page emits
-* (`Runtime.consoleAPICalled`, `Network.*`) flow back here. We buffer recent
-* events in ring buffers the tool layer reads via `getBufferedEvents`.
-*
-* Node-only: imports `ws`. Never bundled into the browser/in-app entries.
-*
-* Attach reliability (#281):
-*   `refreshTargets()` emits an internal 'target:attached' event whenever a
-*   new target is added to the relay. `waitForFirstTarget()` awaits that event
-*   (with a polling-interval fallback) so `start_attach`'s attach wait
-*   resolves deterministically rather than racing between polling rounds.
-*/
-/** Max events retained per domain ring buffer. */
-const DEFAULT_BUFFER_SIZE = 500;
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function parseInbound(raw) {
-	let parsed;
-	try {
-		parsed = JSON.parse(raw);
-	} catch {
-		return null;
-	}
-	if (!isObject(parsed)) return null;
-	const message = {};
-	if (typeof parsed.id === "number") message.id = parsed.id;
-	if (typeof parsed.method === "string") message.method = parsed.method;
-	if ("params" in parsed) message.params = parsed.params;
-	if ("result" in parsed) message.result = parsed.result;
-	if (isObject(parsed.error) && typeof parsed.error.message === "string") message.error = { message: parsed.error.message };
-	return message;
-}
-const PHASE_1_EVENTS = [
-	"Runtime.consoleAPICalled",
-	"Network.requestWillBeSent",
-	"Network.responseReceived"
-];
-/**
-* Ring buffer size for `Runtime.exceptionThrown`.
-*
-* Exceptions are rarer than console messages but each is heavier (stack
-* trace). 50 is generous enough to cover a crash scenario while keeping
-* memory bounded.
-*
-* **Lifecycle note**: the exception buffer intentionally survives `replaced` /
-* `crashed` / `destroyed` lifecycle events — it is NOT cleared on target
-* transitions. Rationale: an exception fired just before a crash is exactly
-* the signal we want to preserve for root-cause analysis. The buffer
-* represents "exceptions seen in this MCP session", not "exceptions in the
-* current page".
-*/
-const EXCEPTION_BUFFER_SIZE = 50;
-/** Default per-command timeout if neither option nor env var is set. */
-const DEFAULT_COMMAND_TIMEOUT_MS = 3e4;
-/**
-* Production CDP connection. Polls the relay for the first attached target,
-* opens a client websocket to it, enables Phase 1 domains, and buffers events.
-*/
-var ChiiCdpConnection = class {
-	/** Authoritative connection kind (issue #348) — relay-backed. */
-	kind = "relay";
-	relayBaseUrl;
-	bufferSize;
-	commandTimeoutMs;
-	totpSecret;
-	emitter = new EventEmitter();
-	buffers = /* @__PURE__ */ new Map();
-	targets = /* @__PURE__ */ new Map();
-	ws = null;
-	connectionState = "idle";
-	nextCommandId = 1;
-	/**
-	* The single active target id under the single-attach model.
-	* Updated by `refreshTargets()` whenever a non-null target is present.
-	* Used to detect a new (different) target attach and evict the previous one.
-	*/
-	activeTargetId = null;
-	/** In-flight enableDomains() promise — concurrent callers share it. */
-	enablingPromise = null;
-	/** Pending request→response commands keyed by CDP message id. */
-	pending = /* @__PURE__ */ new Map();
-	/**
-	* Timestamp (ms since epoch) of the most recent crash/destroy/detach event,
-	* or `null` if no crash has been detected since the last `enableDomains()`.
-	*/
-	lastCrashDetectedAt = null;
-	/**
-	* Per-target last-seen timestamp (ms since epoch). Updated on any inbound
-	* CDP message carrying data from a target. Keyed by target id.
-	*/
-	targetLastSeenAt = /* @__PURE__ */ new Map();
-	/** Active heartbeat interval handle (only when `AIT_CDP_HEARTBEAT_MS` is set). */
-	heartbeatHandle = null;
-	/** Lifecycle event listeners (crash / destroyed / detached). */
-	lifecycleListeners = [];
-	constructor(options) {
-		this.relayBaseUrl = options.relayBaseUrl.replace(/\/$/, "");
-		this.bufferSize = options.bufferSize ?? DEFAULT_BUFFER_SIZE;
-		this.totpSecret = options.totpSecret;
-		const envMs = process.env.AIT_CDP_COMMAND_TIMEOUT_MS ? Number(process.env.AIT_CDP_COMMAND_TIMEOUT_MS) : void 0;
-		this.commandTimeoutMs = (envMs !== void 0 && Number.isFinite(envMs) && envMs > 0 ? envMs : void 0) ?? options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
-		for (const event of PHASE_1_EVENTS) this.buffers.set(event, []);
-		this.buffers.set("Runtime.exceptionThrown", []);
-		this.emitter.setMaxListeners(0);
-	}
-	/** Refresh the attached-target list from the relay's `GET /targets`. */
-	async refreshTargets() {
-		let targetsUrl = `${this.relayBaseUrl}/targets`;
-		if (this.totpSecret) {
-			const code = generateTotp(this.totpSecret);
-			targetsUrl += `?at=${encodeURIComponent(code)}`;
-		}
-		const res = await fetch(targetsUrl);
-		if (!res.ok) throw new Error(`Chii relay /targets returned HTTP ${res.status} ${res.statusText}`);
-		const body = await res.json();
-		const list = isObject(body) && Array.isArray(body.targets) ? body.targets : [];
-		let newestTargetId = null;
-		for (const item of list) {
-			if (!isObject(item) || typeof item.id !== "string") continue;
-			newestTargetId = item.id;
-		}
-		if (newestTargetId !== null && this.activeTargetId !== null && newestTargetId !== this.activeTargetId) {
-			const prevId = this.activeTargetId;
-			logInfo("page.detached", { prevTargetId: prevId });
-			this.evictTarget(prevId);
-		}
-		this.targets.clear();
-		for (const item of list) {
-			if (!isObject(item) || typeof item.id !== "string") continue;
-			if (item.id !== newestTargetId) continue;
-			this.targets.set(item.id, {
-				id: item.id,
-				title: typeof item.title === "string" ? item.title : "",
-				url: typeof item.url === "string" ? item.url : ""
-			});
-		}
-		if (newestTargetId !== null) this.activeTargetId = newestTargetId;
-		else this.activeTargetId = null;
-		const result = [...this.targets.values()];
-		if (newestTargetId !== null) this.emitter.emit("target:attached", result);
-		return result;
-	}
-	listTargets() {
-		return [...this.targets.values()];
-	}
-	/**
-	* Waits until at least one target matching `filterFn` is attached, then
-	* resolves with the full target list at that moment.
-	*
-	* Resolution happens on whichever comes first:
-	*   (a) a `'target:attached'` event from `refreshTargets()` (triggered by
-	*       the /targets poll finding a new target), OR
-	*   (b) a `'target:attached'` event from `handleMessage()` (triggered by
-	*       the first inbound CDP message from a target — confirms the relay
-	*       websocket has data from the phone, not just a target entry in the map).
-	*
-	* This dual-signal approach eliminates the polling race that previously
-	* caused `wait_for_attach` to resolve before the first CDP message arrived.
-	*
-	* Falls back to checking `listTargets()` every `pollIntervalMs` in case the
-	* EventEmitter is missed (defensive belt-and-suspenders).
-	*
-	* @param filterFn  - Predicate that the returned targets must satisfy.
-	* @param timeoutMs - Reject after this many ms (default 90 000).
-	* @param pollIntervalMs - Fallback poll interval (default 500ms).
-	*/
-	waitForFirstTarget(filterFn, timeoutMs = 9e4, pollIntervalMs = 500) {
-		const current = this.listTargets();
-		if (filterFn(current)) return Promise.resolve(current);
-		return new Promise((resolve, reject) => {
-			let settled = false;
-			let pollHandle = null;
-			const settle = (targets) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timeoutHandle);
-				if (pollHandle !== null) {
-					clearInterval(pollHandle);
-					pollHandle = null;
-				}
-				this.emitter.off("target:attached", onAttach);
-				resolve(targets);
-			};
-			const onAttach = (targets) => {
-				if (filterFn(targets)) settle(targets);
-			};
-			const timeoutHandle = setTimeout(() => {
-				if (settled) return;
-				settled = true;
-				if (pollHandle !== null) {
-					clearInterval(pollHandle);
-					pollHandle = null;
-				}
-				this.emitter.off("target:attached", onAttach);
-				reject(/* @__PURE__ */ new Error(`waitForFirstTarget: 타임아웃 (${timeoutMs}ms) — 폰이 relay에 attach되지 않았습니다.`));
-			}, timeoutMs);
-			this.emitter.on("target:attached", onAttach);
-			pollHandle = setInterval(() => {
-				this.refreshTargets().then((targets) => {
-					if (filterFn(targets)) settle(targets);
-				}, () => {});
-			}, pollIntervalMs);
-		});
-	}
-	/**
-	* Timestamp (ms since epoch) of the most recent crash/destroy/detach event
-	* detected since the last `enableDomains()` call, or `null` if none.
-	*/
-	getLastCrashDetectedAt() {
-		return this.lastCrashDetectedAt;
-	}
-	/**
-	* Last-seen timestamp (ms since epoch) for a given target id, or `null` if
-	* the target is unknown / no message has been received from it yet.
-	*/
-	getTargetLastSeenAt(targetId) {
-		return this.targetLastSeenAt.get(targetId) ?? null;
-	}
-	/** Subscribe to target lifecycle events (crash / destroyed / detached). */
-	onLifecycle(listener) {
-		this.lifecycleListeners.push(listener);
-		return () => {
-			const idx = this.lifecycleListeners.indexOf(listener);
-			if (idx !== -1) this.lifecycleListeners.splice(idx, 1);
-		};
-	}
-	/**
-	* Connect a client websocket to the first attached target and enable Phase 1
-	* domains. Resolves once the socket is open and enable commands are sent.
-	*/
-	async enableDomains() {
-		if (this.ws && this.ws.readyState === WebSocket.OPEN) return;
-		if (this.enablingPromise) return this.enablingPromise;
-		this.enablingPromise = this._doEnableDomains().finally(() => {
-			this.enablingPromise = null;
-		});
-		return this.enablingPromise;
-	}
-	async _doEnableDomains() {
-		const target = (await this.refreshTargets())[0];
-		if (!target) throw new Error("No mini-app page attached to the Chii relay yet.");
-		let clientUrl = `${this.relayBaseUrl.replace(/^http/, "ws")}/client/${`devtools-mcp-${Date.now()}`}?target=${encodeURIComponent(target.id)}`;
-		if (this.totpSecret) {
-			const code = generateTotp(this.totpSecret);
-			clientUrl += `&at=${encodeURIComponent(code)}`;
-		}
-		const ws = new WebSocket(clientUrl);
-		this.ws = ws;
-		await new Promise((resolve, reject) => {
-			ws.once("open", () => resolve());
-			ws.once("error", (err) => reject(err));
-			ws.once("close", (code) => {
-				if (code === 4401) reject(/* @__PURE__ */ new Error("relay 인증(TOTP)이 거부됐습니다 (close 4401). 코드가 만료됐을 수 있습니다 — 재연결 시 새 코드가 발급됩니다."));
-			});
-		});
-		this.lastCrashDetectedAt = null;
-		this.targetLastSeenAt.clear();
-		this.connectionState = "connected";
-		ws.on("message", (data) => this.handleMessage(data.toString()));
-		ws.on("close", (code) => this.handleDisconnect(code === 4401 ? "relay 인증(TOTP)이 거부돼 연결이 종료됐습니다 (close 4401)" : "relay WebSocket 연결이 끊겼습니다"));
-		ws.on("error", (err) => this.handleDisconnect(`relay WebSocket 오류: ${err.message}`));
-		this.sendFireAndForget("Runtime.enable");
-		this.sendFireAndForget("Network.enable");
-		this.sendFireAndForget("DOM.enable");
-		this.sendFireAndForget("Page.enable");
-		this.sendFireAndForget("Inspector.enable");
-		this.sendFireAndForget("Target.setDiscoverTargets", { discover: true });
-		this.startHeartbeat(target.id);
-	}
-	/** Fire-and-forget CDP message (used for `*.enable`, no result awaited). */
-	sendFireAndForget(method, params = {}) {
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-		const id = this.nextCommandId++;
-		this.ws.send(JSON.stringify({
-			id,
-			method,
-			params
-		}));
-	}
-	/**
-	* Issue a CDP command and resolve with its result (Phase 2). Rejects on a CDP
-	* error frame or when no websocket is open (no page attached yet).
-	*/
-	send(method, params) {
-		return this.sendCommand(method, params ?? {});
-	}
-	/**
-	* Issue an arbitrary request→response command over the relay and resolve with
-	* its raw result. Both the typed CDP {@link send} and the AIT domain (Phase 3
-	* `AIT.*` methods, forwarded over the same Chii channel) build on this.
-	*
-	* Rejects immediately if the connection is disconnected (fail-fast — no
-	* auto-reconnect). Caller should re-run `list_pages` or `enableDomains` to
-	* reattach.
-	*
-	* Times out after `commandTimeoutMs` (default 30s, env
-	* `AIT_CDP_COMMAND_TIMEOUT_MS`). On timeout the pending entry is cleaned up
-	* and the promise rejects with a descriptive Korean error.
-	*/
-	sendCommand(method, params = {}) {
-		if (this.connectionState === "disconnected") return Promise.reject(/* @__PURE__ */ new Error(`relay에 연결되어 있지 않습니다 (${method}). list_pages로 attach 상태를 확인하고 enableDomains()로 재연결하세요.`));
-		if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("No mini-app page attached to the Chii relay yet. Call enableDomains() first."));
-		const id = this.nextCommandId++;
-		const ws = this.ws;
-		const timeoutMs = this.commandTimeoutMs;
-		return new Promise((resolve, reject) => {
-			const handle = setTimeout(() => {
-				this.pending.delete(id);
-				reject(/* @__PURE__ */ new Error(`CDP 명령이 타임아웃됐습니다 (${method}, ${timeoutMs}ms). 폰 측 토스 앱이 백그라운드로 내려갔거나 미니앱이 unload됐을 수 있습니다. list_pages로 attach 상태를 확인하세요.`));
-			}, timeoutMs);
-			this.pending.set(id, {
-				resolve: (v) => {
-					clearTimeout(handle);
-					resolve(v);
-				},
-				reject: (e) => {
-					clearTimeout(handle);
-					reject(e);
-				}
-			});
-			ws.send(JSON.stringify({
-				id,
-				method,
-				params
-			}));
-		});
-	}
-	/**
-	* Called on WebSocket `close` or `error` after a successful connection.
-	* Rejects all pending commands and marks the connection as disconnected so
-	* subsequent `sendCommand` calls fail fast (no auto-reconnect).
-	*/
-	handleDisconnect(reason) {
-		if (this.connectionState === "disconnected") return;
-		this.connectionState = "disconnected";
-		this.ws = null;
-		this.stopHeartbeat();
-		const err = /* @__PURE__ */ new Error(`${reason}. list_pages로 attach 상태를 확인하고 enableDomains()로 재연결하세요.`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-	}
-	/**
-	* Evict a previously active target under the single-attach model.
-	* Rejects pending commands with a 'replaced-by-new-attach' reason and emits
-	* a 'replaced' lifecycle event. Does NOT clear all targets — only the specific
-	* targetId. The caller is responsible for rebuilding the targets map afterwards.
-	*
-	* The error message uses 'replaced-by-new-attach' so test assertions can match it.
-	*/
-	evictTarget(targetId) {
-		const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.targets.delete(targetId);
-		this.targetLastSeenAt.delete(targetId);
-		const err = /* @__PURE__ */ new Error(`[ait-debug] replaced-by-new-attach — 이전 page 세션이 새 attach로 교체됐습니다 (targetId=${targetId}). list_pages로 현재 attach 상태를 확인하세요.`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-		const event = {
-			kind: "replaced",
-			targetId,
-			detectedAt
-		};
-		for (const listener of this.lifecycleListeners) try {
-			listener(event);
-		} catch {}
-	}
-	/**
-	* Handle a page-level crash or target destruction event.
-	* Removes the target from the in-memory map, rejects all pending commands,
-	* and emits a lifecycle event.
-	*
-	* @param kind - Event kind: 'crashed' | 'destroyed' | 'detached'
-	* @param targetId - The target ID from the event params (may be null for
-	*   Inspector.targetCrashed which has no targetId in the params).
-	*/
-	handleTargetGone(kind, targetId) {
-		const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
-		this.lastCrashDetectedAt = Date.now();
-		if (targetId !== null) {
-			this.targets.delete(targetId);
-			this.targetLastSeenAt.delete(targetId);
-			if (this.activeTargetId === targetId) this.activeTargetId = null;
-		} else {
-			this.targets.clear();
-			this.targetLastSeenAt.clear();
-			this.activeTargetId = null;
-		}
-		const err = /* @__PURE__ */ new Error(`[ait-debug] ${kind === "crashed" ? "page crash (Inspector.targetCrashed)" : kind === "destroyed" ? "target 종료 (Target.targetDestroyed)" : "target detach (Target.detachedFromTarget)"} 감지됨 — relay에서 제거됐습니다. 새 attach가 필요합니다 (list_pages로 확인 → enableDomains()로 재연결).`);
-		for (const waiter of this.pending.values()) waiter.reject(err);
-		this.pending.clear();
-		const event = {
-			kind,
-			targetId,
-			detectedAt
-		};
-		for (const listener of this.lifecycleListeners) try {
-			listener(event);
-		} catch {}
-	}
-	/**
-	* Start the optional CDP heartbeat loop.
-	*
-	* When `AIT_CDP_HEARTBEAT_MS` is set to a positive integer, every interval
-	* we send `Runtime.evaluate({expression: '1'})` to each active target. If
-	* the command times out (2 s hard deadline) or errors, we treat the target
-	* as dead and call `handleTargetGone`.
-	*
-	* This is a zombie-detector fallback: cloudflared keeps-alive the tunnel ws
-	* even when the phone app has crashed, so the ws-level disconnect (#252) won't
-	* fire. The heartbeat catches this gap.
-	*
-	* Default: OFF. Only activates when `AIT_CDP_HEARTBEAT_MS` is set.
-	*/
-	startHeartbeat(initialTargetId) {
-		this.stopHeartbeat();
-		const envMs = process.env.AIT_CDP_HEARTBEAT_MS ? Number(process.env.AIT_CDP_HEARTBEAT_MS) : void 0;
-		if (envMs === void 0 || !Number.isFinite(envMs) || envMs <= 0) return;
-		const PING_TIMEOUT_MS = 2e3;
-		this.heartbeatHandle = setInterval(() => {
-			const targetIds = this.targets.size > 0 ? [...this.targets.keys()] : [initialTargetId];
-			for (const targetId of targetIds) {
-				const pingPromise = this.sendCommand("Runtime.evaluate", {
-					expression: "1",
-					returnByValue: true,
-					timeout: PING_TIMEOUT_MS
-				});
-				const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("heartbeat timeout")), PING_TIMEOUT_MS + 500));
-				Promise.race([pingPromise, timeoutPromise]).catch(() => {
-					if (this.targets.has(targetId)) this.handleTargetGone("destroyed", targetId);
-				});
-			}
-		}, envMs);
-	}
-	stopHeartbeat() {
-		if (this.heartbeatHandle !== null) {
-			clearInterval(this.heartbeatHandle);
-			this.heartbeatHandle = null;
-		}
-	}
-	handleMessage(raw) {
-		const message = parseInbound(raw);
-		if (!message) return;
-		if (typeof message.id === "number" && this.pending.has(message.id)) {
-			const waiter = this.pending.get(message.id);
-			this.pending.delete(message.id);
-			if (waiter) if (message.error) waiter.reject(new Error(message.error.message));
-			else waiter.resolve(message.result);
-			return;
-		}
-		const now = Date.now();
-		let firstMessageSeen = false;
-		for (const targetId of this.targets.keys()) {
-			if (!this.targetLastSeenAt.has(targetId)) firstMessageSeen = true;
-			this.targetLastSeenAt.set(targetId, now);
-		}
-		if (firstMessageSeen && this.targets.size > 0) this.emitter.emit("target:attached", [...this.targets.values()]);
-		if (typeof message.method !== "string") return;
-		if (message.method === "Inspector.targetCrashed") {
-			this.handleTargetGone("crashed", null);
-			return;
-		}
-		if (message.method === "Target.targetDestroyed") {
-			const targetId = isObject(message.params) && typeof message.params.targetId === "string" ? message.params.targetId : null;
-			this.handleTargetGone("destroyed", targetId);
-			return;
-		}
-		if (message.method === "Target.detachedFromTarget") {
-			const targetId = isObject(message.params) && typeof message.params.targetId === "string" ? message.params.targetId : null;
-			this.handleTargetGone("detached", targetId);
-			return;
-		}
-		if (!this.buffers.has(message.method)) return;
-		const event = message.method;
-		const buffer = this.buffers.get(event);
-		if (!buffer) return;
-		buffer.push(message.params);
-		const cap = event === "Runtime.exceptionThrown" ? EXCEPTION_BUFFER_SIZE : this.bufferSize;
-		if (buffer.length > cap) buffer.shift();
-		this.emitter.emit(event, message.params);
-	}
-	getBufferedEvents(event) {
-		return this.buffers.get(event) ?? [];
-	}
-	on(event, listener) {
-		this.emitter.on(event, listener);
-		return () => this.emitter.off(event, listener);
-	}
-	/** Close the relay client websocket and reject any in-flight commands. */
-	close() {
-		const ws = this.ws;
-		this.stopHeartbeat();
-		this.handleDisconnect("Chii relay connection closed");
-		ws?.close();
-	}
-};
-//#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;
-			}
-			httpServer.close(() => resolve());
-		})
-	};
-}
-//#endregion
-//#region src/mcp/debug-server.ts
-/**
-* 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 };
-
-//# sourceMappingURL=debug-server-1dhDA3aw.js.map