@ait-co/devtools 0.1.121 → 0.1.123

package/dist/relay-factory-DVI7TrX4.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"relay-factory-DVI7TrX4.js","names":[],"sources":["../src/test-runner/relay-factory.ts"],"sourcesContent":["/**\n * Relay connection factory for the Vitest custom pool (devtools#696).\n *\n * The Vitest pool (`pool.ts`) takes a {@link RelayConnectionFactory} that knows\n * how to `open()` a live CDP relay connection (boot relay → QR → phone scan →\n * cell inject → enableDomains) and `close()` it. Before this module that exact\n * assembly lived only inside the `devtools-test` CLI's `main()`; the standalone\n * CLI and the Vitest pool would otherwise each hand-roll it and drift.\n *\n * This is the single source of that assembly. `cli.ts` is refactored to call\n * `createRelayConnectionFactory(...).open()`, and `definePhoneVitestConfig`\n * (config.ts) exposes it so a downstream `vitest.config.ts` can wire the pool:\n *\n *   import { createRelayConnectionFactory } from '@ait-co/devtools/test-runner';\n *   const connection = createRelayConnectionFactory({\n *     schemeUrl,\n *     cell,\n *     // REQUIRED — own the stdout decision (the chunks carry the relay wss +\n *     // TOTP code). Suppress on non-interactive stdout; print otherwise.\n *     onQrContent: (chunks) => {\n *       if (!process.stdout.isTTY) return;\n *       for (const c of chunks) process.stdout.write(`${c}\\n`);\n *     },\n *   });\n *   export default defineConfig({ test: definePhoneVitestConfig({ connection }) });\n *\n * The heavy boot graph (chii relay, cloudflared, ws, debug-server) is pulled via\n * DYNAMIC import inside `open()` — so merely importing this module (or the\n * `@ait-co/devtools/test-runner` barrel) does NOT statically drag that graph in.\n *\n * SECRET-HANDLING: relay wss URLs, scheme URLs, and the TOTP secret/code are\n * never logged. `open()` reads the project-local `.ait_relay` secret read-only\n * (never mints) and the minted TOTP code rides only inside the QR `at=` param.\n *\n * Node-only. react-free (CdpConnection + lazily-imported MCP boot helpers only).\n */\n\nimport type { AttachDeps } from '../mcp/attach-orchestrator.js';\nimport type { CdpConnection } from '../mcp/cdp-connection.js';\nimport type { RelayConnectionFactory } from './pool.js';\n\n// NOTE: every value import below is a DYNAMIC import inside `open()`. This module\n// keeps ONLY type-level static imports so that re-exporting it from the\n// `@ait-co/devtools/test-runner` barrel (config.ts) does NOT statically drag the\n// heavy MCP graph (cell.ts → attach-orchestrator.ts → tools.ts → server-lock,\n// plus chii/cloudflared via debug-server) onto that Node-config entry.\n\n/** Options for {@link createRelayConnectionFactory}. */\nexport interface RelayConnectionFactoryOptions {\n  /**\n   * intoss-private:// scheme URL from `ait deploy --scheme-only` (env3). The\n   * phone cold-loads the candidate bundle this URL points at. SECRET-HANDLING:\n   * never logged.\n   */\n  schemeUrl: string;\n  /**\n   * Project root for the `.ait_relay` secret lookup (read-only). Defaults to\n   * `process.cwd()`.\n   */\n  projectRoot?: string;\n  /**\n   * Attach wait timeout in ms — how long `open()` waits for the phone to scan\n   * the QR and attach. Defaults to 600 000 (10 min) to give time for a manual\n   * scan. (The per-file evaluate timeout is separate, passed via the pool's\n   * `run` options.)\n   */\n  timeoutMs?: number;\n  /** Disable browser auto-open of the QR dashboard (text QR only). */\n  headless?: boolean;\n  /**\n   * Cell axes injected as `__AIT_CELL__` before the first test bundle runs, so\n   * sdk-example's capture picks up the correct sdkLine/platform. Optional — when\n   * omitted no cell is injected. The values are not secrets.\n   */\n  cell?: { sdkLine: string; platform: string };\n  /**\n   * Receives the QR/attach render content (text chunks) from\n   * `renderAndMaybeWait`, so the caller decides whether to print them — e.g.\n   * suppress on non-interactive stdout.\n   *\n   * REQUIRED (not optional) on purpose: these chunks contain the QR payload\n   * (which encodes the relay wss + TOTP `at=` code) and the attach JSON block.\n   * Making the hook mandatory means the factory never falls back to printing\n   * them itself — a downstream `vitest.config.ts` consumer that wires this via\n   * the `@ait-co/devtools/test-runner` barrel is forced to make an explicit\n   * stdout decision rather than silently leaking the secret-bearing block.\n   *\n   * SECRET-HANDLING: when a non-interactive caller is detected the hook MUST\n   * suppress the WHOLE chunk (not just `attachUrl`), since `relayUrl` rides in\n   * the same block.\n   */\n  onQrContent: (textChunks: string[]) => void;\n}\n\n/**\n * Builds a {@link RelayConnectionFactory} that opens a standalone env3 relay\n * connection.\n *\n * `open()` performs the full attach lifecycle and BLOCKS for tens of seconds (up\n * to `timeoutMs`) while a human scans the rendered QR with their phone — there\n * is no way around the manual scan for env3. It resolves with the live\n * `CdpConnection` once a matching page attaches; `close()` tears the relay\n * family down.\n *\n * The factory holds the booted relay family in a closure so `close()` can stop\n * it. A second `open()` on the same factory boots a fresh family (the previous\n * one should have been `close()`d first).\n */\nexport function createRelayConnectionFactory(\n  opts: RelayConnectionFactoryOptions,\n): RelayConnectionFactory {\n  const projectRoot = opts.projectRoot ?? process.cwd();\n  const timeoutMs = opts.timeoutMs ?? 600_000;\n  const headless = opts.headless === true;\n\n  // Captured so close() can stop the family that open() booted.\n  let family: { connection: CdpConnection; stop(): void } | undefined;\n\n  return {\n    async open(): Promise<CdpConnection> {\n      // Dynamic imports: keep the chii/cloudflared/debug-server graph OFF the\n      // static import graph of this module (and the test-runner config barrel).\n      const { prepareAttach, renderAndMaybeWait } = await import('../mcp/attach-orchestrator.js');\n      const { injectDebugIndicator, injectGlobals } = await import('./cell.js');\n      const { loadRelaySecretReadOnly } = await import('../mcp/relay-secret-store.js');\n      const { bootRelayFamily, buildRelayVerifyAuth } = await import('../mcp/debug-server.js');\n\n      // Load the project-local .ait_relay secret into AIT_DEBUG_TOTP_SECRET\n      // BEFORE booting the relay so assertRelayAuthConfigured()/buildRelayVerifyAuth()\n      // at the boot site see it. Read-only — never mints. SECRET-HANDLING: the\n      // value is never logged here.\n      await loadRelaySecretReadOnly({ projectRoot });\n\n      const booted = await bootRelayFamily({ verifyAuth: buildRelayVerifyAuth() });\n      family = booted;\n\n      // Assemble AttachDeps with no dashboard/SSE (CLI/pool is not the daemon).\n      const attachDeps: AttachDeps = {\n        getTunnelStatus: booted.getTunnelStatus ?? (() => ({ up: false, wssUrl: null })),\n        getTotpSecret: () => process.env.AIT_DEBUG_TOTP_SECRET,\n        qrHttpServer: undefined,\n        onAttachUrlBuilt: undefined,\n        canOpenBrowser: () => !headless,\n      };\n\n      const prep = await prepareAttach(\n        attachDeps,\n        'relay-dev',\n        { scheme_url: opts.schemeUrl },\n        booted.connection,\n      );\n      if (!prep.ok) {\n        booted.stop();\n        family = undefined;\n        // SECRET-HANDLING: do NOT surface `prep.error.content` in the thrown\n        // message. Some prep error paths build their text from attach\n        // components, and the CLI catch writes `e.message` to stderr — embedding\n        // that text risks leaking the scheme/relay wss URL. The detailed\n        // diagnostic is the daemon/dashboard's job; the factory throws a\n        // secret-free message only.\n        throw new Error(\n          'createRelayConnectionFactory: attach preparation failed — check the scheme_url and that the relay tunnel is up',\n        );\n      }\n\n      // Render the QR + wait for the phone to attach. SECRET-HANDLING: this\n      // function never logs scheme/wss/TOTP values.\n      const waitResult = await renderAndMaybeWait(\n        attachDeps,\n        prep,\n        true,\n        timeoutMs,\n        booted.connection,\n      );\n      if (waitResult.isError) {\n        booted.stop();\n        family = undefined;\n        // SECRET-HANDLING (BLOCKER fix): `waitResult.content` is the timeout\n        // result built from `buildTimeoutError(baseText, ...)`, and `baseText`\n        // is `JSON.stringify({ attachUrl, relayUrl, ... })` — `attachUrl` carries\n        // the TOTP `at=` code and `relayUrl` is the relay `wss://` URL. The CLI\n        // catch writes `e.message` to stderr, so extracting that text here would\n        // leak the relay wss + TOTP code on every timeout. Throw a secret-free\n        // message with only the timeout duration.\n        const timeoutSec = Math.round(timeoutMs / 1000);\n        throw new Error(\n          `createRelayConnectionFactory: attach timed out after ${timeoutSec}s — phone did not scan the QR within the timeout`,\n        );\n      }\n\n      // Surface the QR/attach render content to the caller, which owns the\n      // stdout decision (suppress on non-interactive stdout). There is no\n      // fallback that prints here itself: `onQrContent` is a required option so\n      // the secret-bearing block (attachUrl TOTP + relayUrl wss) can never be\n      // emitted without an explicit caller decision. SECRET-HANDLING.\n      const qrChunks = waitResult.content\n        .filter((c): c is { type: 'text'; text: string } => c.type === 'text')\n        .map((c) => c.text);\n      opts.onQrContent(qrChunks);\n\n      // Debugger attached — show the on-phone \"Debugger Connected\" badge.\n      await injectDebugIndicator(booted.connection);\n\n      // Inject the cell globals before any test bundle runs (session-global).\n      if (opts.cell !== undefined) {\n        await injectGlobals(booted.connection, { __AIT_CELL__: opts.cell });\n      }\n\n      // Open the CDP client websocket + enable domains so the first run's\n      // Runtime.evaluate and console stream are live. enableDomains is\n      // idempotent; runTestFilesOverRelay also calls it defensively.\n      await booted.connection.enableDomains();\n\n      return booted.connection;\n    },\n\n    async close(_connection: CdpConnection): Promise<void> {\n      // family.stop() is synchronous best-effort: closes the CDP connection and\n      // shuts down the relay + cloudflared child.\n      family?.stop();\n      family = undefined;\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4GA,SAAgB,6BACd,MACwB;CACxB,MAAM,cAAc,KAAK,eAAe,QAAQ,KAAK;CACrD,MAAM,YAAY,KAAK,aAAa;CACpC,MAAM,WAAW,KAAK,aAAa;CAGnC,IAAI;AAEJ,QAAO;EACL,MAAM,OAA+B;GAGnC,MAAM,EAAE,eAAe,uBAAuB,MAAM,OAAO;GAC3D,MAAM,EAAE,sBAAsB,kBAAkB,MAAM,OAAO;GAC7D,MAAM,EAAE,4BAA4B,MAAM,OAAO;GACjD,MAAM,EAAE,iBAAiB,yBAAyB,MAAM,OAAO;AAM/D,SAAM,wBAAwB,EAAE,aAAa,CAAC;GAE9C,MAAM,SAAS,MAAM,gBAAgB,EAAE,YAAY,sBAAsB,EAAE,CAAC;AAC5E,YAAS;GAGT,MAAM,aAAyB;IAC7B,iBAAiB,OAAO,2BAA2B;KAAE,IAAI;KAAO,QAAQ;KAAM;IAC9E,qBAAqB,QAAQ,IAAI;IACjC,cAAc,KAAA;IACd,kBAAkB,KAAA;IAClB,sBAAsB,CAAC;IACxB;GAED,MAAM,OAAO,MAAM,cACjB,YACA,aACA,EAAE,YAAY,KAAK,WAAW,EAC9B,OAAO,WACR;AACD,OAAI,CAAC,KAAK,IAAI;AACZ,WAAO,MAAM;AACb,aAAS,KAAA;AAOT,UAAM,IAAI,MACR,iHACD;;GAKH,MAAM,aAAa,MAAM,mBACvB,YACA,MACA,MACA,WACA,OAAO,WACR;AACD,OAAI,WAAW,SAAS;AACtB,WAAO,MAAM;AACb,aAAS,KAAA;IAQT,MAAM,aAAa,KAAK,MAAM,YAAY,IAAK;AAC/C,UAAM,IAAI,MACR,wDAAwD,WAAW,kDACpE;;GAQH,MAAM,WAAW,WAAW,QACzB,QAAQ,MAA2C,EAAE,SAAS,OAAO,CACrE,KAAK,MAAM,EAAE,KAAK;AACrB,QAAK,YAAY,SAAS;AAG1B,SAAM,qBAAqB,OAAO,WAAW;AAG7C,OAAI,KAAK,SAAS,KAAA,EAChB,OAAM,cAAc,OAAO,YAAY,EAAE,cAAc,KAAK,MAAM,CAAC;AAMrE,SAAM,OAAO,WAAW,eAAe;AAEvC,UAAO,OAAO;;EAGhB,MAAM,MAAM,aAA2C;AAGrD,WAAQ,MAAM;AACd,YAAS,KAAA;;EAEZ"}

package/dist/relay-secret-store-BlFEhqwb.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { n as loadRelaySecretReadOnly } from "./relay-secret-store-CmDDfZMh.js";
-export { loadRelaySecretReadOnly };

package/dist/test-runner/cli.d.ts

@@ -1,547 +0,0 @@
-
-//#region src/mcp/cdp-connection.d.ts
-/**
- * Injectable CDP connection abstraction for the debug-mode MCP server.
- *
- * The Phase 1 tool layer (`list_console_messages`, `list_network_requests`,
- * `list_pages`) reads from CDP events captured off a Chii relay connection.
- * To keep that tool layer CI-verifiable without a phone roundtrip, the actual
- * relay websocket sits behind this interface. Production wires
- * `ChiiCdpConnection` (see `chii-connection.ts`); tests inject a fake that
- * emits canned `Runtime.consoleAPICalled` / `Network.*` events.
- *
- * Phase 2 adds CDP *commands* (request→response): `DOM.getDocument`,
- * `DOMSnapshot.captureSnapshot`, `Page.captureScreenshot`. Unlike Phase 1's
- * event streams these need a `send(method, params)` round-trip, so the
- * connection grows a typed `send`. The fake returns canned command results.
- *
- * Phase 2 extension: `Runtime.evaluate` (read-only probe) added for the
- * `measure_safe_area` tool — executes a JS snippet on the attached page and
- * returns the result as a `RemoteObject`. The fake returns canned results for
- * unit tests without a phone roundtrip.
- *
- * Only the slice of the Chrome DevTools Protocol the tools need is typed here.
- */
-/** A target (page) the Chii relay currently sees attached. */
-interface CdpTarget {
-  /** Chii's internal target id (session UUID). */
-  id: string;
-  /** Page title reported by the in-app target. */
-  title: string;
-  /** Page URL reported by the in-app target. */
-  url: string;
-}
-/** `Runtime.RemoteObject` subset we surface for console args. */
-interface CdpRemoteObject {
-  type: string;
-  subtype?: string;
-  value?: unknown;
-  description?: string;
-  className?: string;
-}
-/** Payload of a `Runtime.consoleAPICalled` event. */
-interface ConsoleApiCalledEvent {
-  /** log | warning | error | info | debug | … */
-  type: string;
-  args: CdpRemoteObject[];
-  /** Milliseconds since epoch (CDP `Runtime.Timestamp`). */
-  timestamp: number;
-  executionContextId?: number;
-  stackTrace?: {
-    callFrames: Array<{
-      functionName: string;
-      url: string;
-      lineNumber: number;
-      columnNumber: number;
-    }>;
-  };
-}
-/** Payload of a `Network.requestWillBeSent` event (subset). */
-interface NetworkRequestWillBeSentEvent {
-  requestId: string;
-  request: {
-    url: string;
-    method: string;
-    headers?: Record<string, string>;
-  };
-  /** CDP `Network.MonotonicTime` (seconds). */
-  timestamp: number;
-  /** Wall-clock seconds since epoch, when available. */
-  wallTime?: number;
-  type?: string;
-}
-/** Payload of a `Network.responseReceived` event (subset). */
-interface NetworkResponseReceivedEvent {
-  requestId: string;
-  response: {
-    url: string;
-    status: number;
-    statusText: string;
-    mimeType?: string;
-  };
-  timestamp: number;
-  type?: string;
-}
-/**
- * A single call frame in a `Runtime.exceptionThrown` stack trace.
- * Subset of the CDP `Runtime.CallFrame` shape.
- */
-interface CdpCallFrame {
-  functionName: string;
-  scriptId?: string;
-  url: string;
-  lineNumber: number;
-  columnNumber: number;
-}
-/** Payload of a `Runtime.exceptionThrown` event. */
-interface RuntimeExceptionThrownEvent {
-  /** Milliseconds since epoch (CDP `Runtime.Timestamp`). */
-  timestamp: number;
-  exceptionDetails: {
-    exceptionId: number;
-    text: string;
-    lineNumber: number;
-    columnNumber: number;
-    scriptId?: string;
-    url?: string;
-    stackTrace?: {
-      callFrames: CdpCallFrame[];
-    }; /** The thrown value as a CDP `RemoteObject`. */
-    exception?: CdpRemoteObject;
-  };
-}
-/** Map of the CDP event names Phase 1 consumes to their payload shapes. */
-interface CdpEventMap {
-  'Runtime.consoleAPICalled': ConsoleApiCalledEvent;
-  'Network.requestWillBeSent': NetworkRequestWillBeSentEvent;
-  'Network.responseReceived': NetworkResponseReceivedEvent;
-  'Runtime.exceptionThrown': RuntimeExceptionThrownEvent;
-}
-type CdpEventName = keyof CdpEventMap;
-/** A `DOM.Node` subset (recursive) returned by `DOM.getDocument`. */
-interface CdpDomNode {
-  nodeId: number;
-  /** CDP node type (1 = element, 3 = text, 9 = document, …). */
-  nodeType: number;
-  nodeName: string;
-  /** Tag/local name for elements. */
-  localName?: string;
-  nodeValue?: string;
-  /** Flattened attribute list: `[name, value, name, value, …]`. */
-  attributes?: string[];
-  childNodeCount?: number;
-  children?: CdpDomNode[];
-  documentURL?: string;
-  baseURL?: string;
-}
-/** Result of `DOM.getDocument`. */
-interface DomGetDocumentResult {
-  root: CdpDomNode;
-}
-/** Result of `DOMSnapshot.captureSnapshot` (subset we surface). */
-interface DomSnapshotResult {
-  documents: unknown[];
-  strings: string[];
-}
-/** Result of `Page.captureScreenshot`. */
-interface PageCaptureScreenshotResult {
-  /** Base64-encoded image bytes (PNG by default). */
-  data: string;
-}
-/**
- * Params for `Runtime.evaluate`.
- * Covers the subset used by the `measure_safe_area` read-only probe.
- */
-interface RuntimeEvaluateParams {
-  /** JavaScript expression to evaluate in the page context. */
-  expression: string;
-  /** Return the result as a plain JSON value (vs. a handle). Default false. */
-  returnByValue?: boolean;
-  /** Await a returned Promise before resolving. Default false. */
-  awaitPromise?: boolean;
-}
-/** Result of `Runtime.evaluate`. */
-interface RuntimeEvaluateResult {
-  /** The evaluation result. */
-  result: CdpRemoteObject;
-  /** Present when evaluation threw an uncaught exception. */
-  exceptionDetails?: {
-    text: string;
-    exception?: CdpRemoteObject;
-  };
-}
-/**
- * Map of CDP command method → params/result shape. Keeps `send` typed so a
- * `DOM.getDocument` call resolves to a `DomGetDocumentResult`, etc.
- */
-interface CdpCommandMap {
-  'DOM.getDocument': {
-    params: {
-      depth?: number;
-      pierce?: boolean;
-    };
-    result: DomGetDocumentResult;
-  };
-  'DOMSnapshot.captureSnapshot': {
-    params: {
-      computedStyles?: string[];
-    };
-    result: DomSnapshotResult;
-  };
-  'Page.captureScreenshot': {
-    params: {
-      format?: 'png' | 'jpeg' | 'webp';
-      quality?: number;
-    };
-    result: PageCaptureScreenshotResult;
-  };
-  'Runtime.evaluate': {
-    params: RuntimeEvaluateParams;
-    result: RuntimeEvaluateResult;
-  };
-}
-type CdpCommandName = keyof CdpCommandMap;
-/**
- * The connection the tool layer reads from. The production implementation
- * wraps the Chii relay's CDP websocket; tests inject a fake.
- *
- * Implementations are expected to maintain an internal ring buffer of recent
- * events (so a tool call returns recent history rather than only live events).
- */
-interface CdpConnection {
-  /**
-   * Authoritative kind of this connection's transport (issue #348).
-   *
-   * - `'relay'` — backed by the Chii relay + cloudflared tunnel (a real-device
-   *   WebView, env 3/4). `ChiiCdpConnection`.
-   * - `'local'` — backed by a direct CDP websocket to a local Chromium (env 1).
-   *   `LocalCdpConnection`.
-   *
-   * This replaces the old `getEnvironment()` URL-pattern sniffing: the
-   * `mock` vs `relay` split is now a free, authoritative property of the
-   * connection itself, known before any target attaches. The `relay-dev` vs
-   * `relay-live` distinction is orthogonal (operator-supplied `liveIntent`,
-   * see `environment.ts`) because dog-food and production relays are
-   * byte-identical on the wire.
-   */
-  readonly kind: 'relay' | 'local';
-  /**
-   * Enable the CDP domains Phase 1 needs (`Runtime.enable`, `Network.enable`).
-   * Idempotent. Resolves once the relay has acknowledged (or immediately for a
-   * fake connection).
-   */
-  enableDomains(): Promise<void>;
-  /** Targets (pages) the relay currently sees attached. */
-  listTargets(): CdpTarget[];
-  /** Recent buffered events for a domain, oldest-first. */
-  getBufferedEvents<E extends CdpEventName>(event: E): ReadonlyArray<CdpEventMap[E]>;
-  /** Subscribe to live events. Returns an unsubscribe function. */
-  on<E extends CdpEventName>(event: E, listener: (payload: CdpEventMap[E]) => void): () => void;
-  /**
-   * Issue a CDP command (request → response). Phase 2's DOM/snapshot/screenshot
-   * tools use this; resolves with the typed result or rejects on a CDP error.
-   * Implementations must have called {@link enableDomains} first.
-   */
-  send<M extends CdpCommandName>(method: M, params?: CdpCommandMap[M]['params']): Promise<CdpCommandMap[M]['result']>;
-  /**
-   * Close the underlying transport and reject any in-flight commands.
-   * Optional so that minimal test fakes that don't need teardown remain
-   * compatible without change. Both `ChiiCdpConnection` and
-   * `LocalCdpConnection` already implement this.
-   */
-  close?(): void;
-  /**
-   * Refresh the attached-target list from the relay and return the result.
-   * Emits an internal `'target:attached'` event when a new target appears so
-   * that {@link waitForFirstTarget} can race against the polling round.
-   *
-   * Optional — only `ChiiCdpConnection` (relay mode) supports this; local
-   * connections and test fakes may omit it. Callers should guard with
-   * `connection.refreshTargets?.()`.
-   */
-  refreshTargets?(): Promise<CdpTarget[]>;
-  /**
-   * Waits until at least one target satisfying `filterFn` is attached, then
-   * resolves with the full target list at that moment.
-   *
-   * Optional — only `ChiiCdpConnection` provides the event-driven
-   * implementation. When absent, callers fall back to a generic polling loop.
-   *
-   * @param filterFn      - Predicate the resolved targets must satisfy.
-   * @param timeoutMs     - Reject after this many ms (default 90 000).
-   * @param pollIntervalMs - Fallback poll interval (default 500 ms).
-   */
-  waitForFirstTarget?(filterFn: (targets: CdpTarget[]) => boolean, timeoutMs?: number, pollIntervalMs?: number): Promise<CdpTarget[]>;
-}
-//#endregion
-//#region src/test-runner/bundle.d.ts
-/**
- * esbuild-based bundler for user test files.
- *
- * Bundles a single test file into a self-contained IIFE string that can be
- * injected into a WebView via `Runtime.evaluate`. The bundle includes the
- * test runtime (`runtime.ts`), which provides `describe/it/test/expect` and
- * the `runTestModule(factory)` entry point.
- *
- * ## How the wiring works
- *
- * The bundle exposes two exports on `globalThis.__testBundle`:
- *   - `runTestModule` — the runtime's entry function.
- *   - `__userFactory`  — an async function whose body is the user's top-level
- *     test registration code (describe/it/test calls).
- *
- * The Node-side RPC (`rpc.ts`) calls:
- *   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
- *
- * `runTestModule` then installs `describe/it/test/expect` as globals, invokes
- * the factory (which registers all tests), runs them, and returns a `RunReport`.
- *
- * ## Why a factory wrapper is needed
- *
- * Naively adding the runtime to `entryPoints` and bundling the user file would
- * fail for two reasons:
- *   1. `describe/it/test/expect` from the runtime are module-local in the IIFE
- *      scope. The user's top-level `describe(...)` calls expect them as globals —
- *      they are not globals until `runTestModule` installs them.
- *   2. Even with globals pre-installed, the user file runs at IIFE-evaluation
- *      time, before the RPC layer calls `runTestModule` to reset state and start
- *      the test clock.
- *
- * The factory approach solves both: the user's registration code is deferred
- * into a function that `runTestModule` calls AFTER installing the globals.
- *
- * ## Factory extraction algorithm
- *
- * The `userFactoryPlugin` reads the user file and splits lines into:
- *   - **top-level**: `import …` and re-export lines — kept at module scope
- *     (the only valid position for static `import` in ESM).
- *   - **body**: all other statements — moved into the body of the exported
- *     `__userFactory` async function.
- *
- * esbuild processes the re-generated module, following each static import
- * through the normal dependency graph (including the SDK-redirect plugin).
- *
- * ## SDK redirect
- *
- * Imports of `@apps-in-toss/web-framework` (and sub-paths) are intercepted via
- * the `sdkRedirectPlugin` and replaced with a virtual `window.__sdk` proxy that
- * `src/in-app/auto.ts` installs at runtime. This works for both 2.x and 3.x SDK.
- *
- * SECRET-HANDLING: the returned bundle code is caller-managed; never log it.
- */
-/** Options accepted by `bundleTestFile`. */
-interface BundleOptions {
-  /**
-   * Additional esbuild `external` patterns. The SDK package
-   * (`@apps-in-toss/web-framework` and `@apps-in-toss/web-framework/*`) is
-   * always handled by the SDK redirect plugin — callers may add more patterns
-   * to be left as globals.
-   */
-  extraExternals?: string[];
-  /**
-   * Global name for the IIFE output object. Defaults to `__testBundle`.
-   * The runtime entry uses this to call `__testBundle.runTestModule(__userFactory)`.
-   */
-  globalName?: string;
-}
-//#endregion
-//#region src/test-runner/capture.d.ts
-/**
- * `__AIT_CAPTURE__` console-line parser (devtools#696).
- *
- * env3 test runs inject sdk-example's `aitCapture.ts`, which — when running in a
- * WebView (no filesystem) — emits one `console.log` line per category in the
- * stable form:
- *
- *   __AIT_CAPTURE__ <category> <json>
- *
- * The relay-worker harvests `Runtime.consoleAPICalled` events as plain text
- * lines (see `relay-worker.ts`) and hands them here. This module's only job is
- * to recognise the allowlisted prefix, split off the category, and keep the
- * remaining JSON string OPAQUE — devtools does NOT own or interpret the
- * `__AIT_CAPTURE__` record shape (that lives in sdk-example). We carry
- * `{ category, json }` through untouched so the 2.x↔3.0 line comparison stays a
- * downstream concern.
- *
- * Why a strict allowlist prefix (SECRET-HANDLING): the raw console stream may
- * also contain wss/scheme/relay noise lines. Only lines that EXACTLY start with
- * `'__AIT_CAPTURE__ '` pass; everything else is discarded, so a stray relay URL
- * can never be serialised into a capture artifact.
- *
- * react-free, dependency-free — safe to import from any test-runner entry
- * without dragging in the chii/cloudflared Node graph.
- */
-/**
- * One parsed capture line. `json` is the raw JSON string exactly as the page
- * emitted it (an array of sdk-example capture records). devtools treats it as
- * opaque — it is validated as parseable JSON but never inspected.
- */
-interface AitCaptureLine {
-  /** The capture category (first whitespace-delimited token after the prefix). */
-  category: string;
-  /** The remaining JSON payload, verbatim. Opaque to devtools. */
-  json: string;
-}
-//#endregion
-//#region src/test-runner/runtime.d.ts
-/**
- * Thin test runtime for WebView execution.
- *
- * This file is bundled by `bundle.ts` together with the user's test file
- * into a single IIFE injected into the WebView via `Runtime.evaluate`.
- * It MUST stay browser-compatible — no Node.js APIs allowed.
- *
- * Design: rather than shipping @vitest/runner verbatim into a WebView (where
- * its Node-side internals cause issues), this runtime provides a minimal
- * compatible API surface — describe/it/test/expect globals — collects results
- * into a plain JSON-safe object, and exports `runTestModule` as the entry point.
- *
- * @vitest/runner and @vitest/expect are listed as dependencies so that the
- * package's type contracts are available and so the browser-compatible subsets
- * can be referenced. The Vitest custom pool that drives this runtime through
- * Vitest's `PoolRunnerInitializer` lives in `pool.ts`.
- *
- * NOTE: this file is imported by type from Node-side code (rpc.ts / relay-worker.ts)
- * for the RunReport / TestResult type shapes. The runtime ITSELF is not imported
- * at runtime on the Node side — only the types are used.
- */
-/**
- * Result of a single test case.
- * All fields are JSON-serialisable.
- */
-interface TestResult {
-  /** Full dot-joined test name including nested suite names. */
-  name: string;
-  /** `'pass'` or `'fail'`. `'skip'` for skipped tests. */
-  status: 'pass' | 'fail' | 'skip';
-  /** Duration in milliseconds. */
-  duration: number;
-  /** Error message (fail only). Does NOT include the expression/secret. */
-  error?: string;
-}
-/** Aggregate report returned by `runTestModule`. */
-interface RunReport {
-  /** ISO timestamp of when `runTestModule` was called. */
-  startedAt: string;
-  /** Total elapsed milliseconds (wall-clock). */
-  duration: number;
-  passed: number;
-  failed: number;
-  skipped: number;
-  tests: TestResult[];
-}
-//#endregion
-//#region src/test-runner/relay-worker.d.ts
-/** Per-file result in the aggregate `RunReport`. */
-interface FileResult {
-  /** Absolute or relative path to the test file. */
-  file: string;
-  /** Full run report for this file, or an error if bundling/injection failed. */
-  result: RunReport | {
-    error: string;
-  };
-}
-/** Aggregate report returned by `runTestFilesOverRelay`. */
-interface RelayRunReport {
-  /** ISO timestamp of when the run started. */
-  startedAt: string;
-  /** Total elapsed wall-clock milliseconds. */
-  duration: number;
-  /** Per-file results in execution order. */
-  files: FileResult[];
-  /** Flattened totals across all files. */
-  totals: {
-    passed: number;
-    failed: number;
-    skipped: number;
-    total: number;
-  };
-  /**
-   * `__AIT_CAPTURE__` lines harvested from the page console during the run
-   * (additive field, devtools#696). Empty unless `collectCaptures` was set.
-   * Each entry is opaque (`{ category, json }`) — devtools does not interpret
-   * the record shape, only forwards it for downstream 2.x↔3.0 diffing.
-   *
-   * SECRET-HANDLING: only lines matching the `__AIT_CAPTURE__ ` allowlist
-   * prefix reach here; relay/wss/scheme noise lines are dropped in
-   * `parseCaptureLines`.
-   */
-  captures: AitCaptureLine[];
-}
-/** Options for `runTestFilesOverRelay`. */
-interface RelayRunOptions {
-  /**
-   * Options forwarded to `bundleTestFile` for each file.
-   */
-  bundleOptions?: BundleOptions;
-  /**
-   * Per-file evaluate timeout in milliseconds. Defaults to 30 000.
-   * Increase for long-running suites or split the file.
-   */
-  timeoutMs?: number;
-  /**
-   * When `true`, registers a live `Runtime.consoleAPICalled` listener for the
-   * duration of the run and harvests `__AIT_CAPTURE__` lines into
-   * `RelayRunReport.captures`. Defaults to **false** so the build-only
-   * eval/e2e path (and the Vitest pool) pay no listener/state overhead —
-   * `captures` is then an empty array.
-   *
-   * The listener is registered just BEFORE the first file runs and removed in a
-   * `finally` so it never accumulates across runs (no ring-buffer drain — the
-   * default 500-entry buffer would silently drop lines via `shift`).
-   */
-  collectCaptures?: boolean;
-}
-//#endregion
-//#region src/test-runner/cli.d.ts
-/** Options for `runWithConnection`. */
-interface RunWithConnectionOptions extends RelayRunOptions {
-  /** If true, print a summary to stdout. Defaults to false in tests. */
-  printSummary?: boolean;
-}
-/**
- * Runs `files` over `connection` and returns the aggregate report.
- * This pure function is the testable core of the CLI (and is what the
- * `run_tests` MCP tool calls against the daemon's attached connection); it is
- * separate from `main()` so tests can call it without spawning a subprocess.
- */
-declare function runWithConnection(connection: CdpConnection, files: string[], opts?: RunWithConnectionOptions): Promise<RelayRunReport>;
-/**
- * Decides whether to suppress the QR/attach block on stdout.
- *
- * Suppress when EITHER the user passed `--no-qr-stdout`, OR stdout is not a TTY
- * / `CI` is set / `AIT_NO_QR_STDOUT` is set (non-interactive — a captured stdout
- * must not leak the relay wss + TOTP `at=` code that the QR block encodes). The
- * suppression is whole-chunk: `attachUrl` AND `relayUrl` ride in the same block.
- *
- * Exported for unit testing.
- */
-declare function shouldSuppressQr(noQrFlag: boolean): boolean;
-/**
- * CLI entry point.
- *
- * Performs a standalone relay attach → run lifecycle, sharing the attach
- * assembly with the Vitest pool via `createRelayConnectionFactory` (single
- * source — no drift):
- *
- * 1. Parse args: globs, --timeout, --cell-sdk-line, --cell-platform,
- *    --scheme-url (required for env3), --report-dir, --no-qr-stdout,
- *    --headless, --project-root.
- * 2. Discover test files; exit 1 if none.
- * 3. factory.open() — boot relay → render QR (suppressed on non-interactive
- *    stdout) → wait for phone → inject cell → enableDomains. Returns the conn.
- * 4. runWithConnection(conn, files, { timeoutMs, collectCaptures, printSummary }).
- * 5. With --report-dir: write the runner-agnostic report + capture files.
- * 6. factory.close(); process.exitCode = failed > 0 ? 1 : 0.
- *
- * The CLI is not a daemon — no lock, router, SSE, or tools_list is needed.
- * Attach timeout exits with code 1; test failures exit with code 1.
- *
- * SECRET-HANDLING: scheme_url / relay wssUrl / TOTP codes are never written to
- * stdout/stderr directly. The QR block (which encodes the TOTP `at=` code) is
- * printed only when stdout is interactive AND not suppressed.
- */
-declare function main(argv?: string[]): Promise<void>;
-//#endregion
-export { RunWithConnectionOptions, main, runWithConnection, shouldSuppressQr };
-//# sourceMappingURL=cli.d.ts.map

package/dist/test-runner/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","names":[],"sources":["../../src/mcp/cdp-connection.ts","../../src/test-runner/bundle.ts","../../src/test-runner/capture.ts","../../src/test-runner/runtime.ts","../../src/test-runner/relay-worker.ts","../../src/test-runner/cli.ts"],"mappings":"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"}

package/dist/test-runner/cli.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { n as runWithConnection, r as shouldSuppressQr, t as main } from "../cli-RhzASQef.js";
-export { main, runWithConnection, shouldSuppressQr };

package/dist/totp-zGIlDsZS.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-import { a as isValidRelayAuthSecret } from "./totp-0bvlo9Yb.js";
-export { isValidRelayAuthSecret };