@ait-co/devtools 0.1.115 → 0.1.116

package/dist/test-runner/cli.js

@@ -1,622 +1,3 @@
 #!/usr/bin/env node
-import { parseArgs } from "node:util";
-import * as fs from "node:fs/promises";
-import { glob } from "node:fs/promises";
-import * as path from "node:path";
-import { isAbsolute, resolve } from "node:path";
-import { accessSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-//#region src/test-runner/discover.ts
-/**
-* Test-file discovery shared by the `devtools-test` CLI and the `run_tests`
-* MCP tool, so both expand glob patterns with identical semantics.
-*
-* Uses Node's built-in `fs/promises` `glob` (Node 22+) — no extra dependency,
-* which keeps the MCP daemon install graph lean (a plain glob lib would land in
-* the `npx … devtools-mcp` path for no benefit).
-*
-* Pure Node IO only (`node:fs/promises` + `node:path`) — react-free, so it is
-* safe to import from the MCP daemon graph.
-*/
-/**
-* Expands `patterns` (globs or plain paths) into a sorted, de-duplicated list of
-* ABSOLUTE test file paths, resolved relative to `cwd`.
-*
-* A plain (non-glob) path passes through when it matches a real file; a glob
-* expands against `cwd`. Absolute matches are kept as-is; relative matches are
-* resolved against `cwd`. `bundleTestFile` requires an absolute path, so the
-* absolute output feeds it directly.
-*
-* @param patterns Glob patterns or file paths (e.g. `['src/**\/*.ait.test.ts']`).
-* @param cwd      Base directory for relative patterns/results.
-* @returns Sorted, de-duplicated absolute file paths. Empty when nothing matches.
-*/
-async function discoverTestFiles(patterns, cwd) {
-	const out = /* @__PURE__ */ new Set();
-	for await (const match of glob(patterns, { cwd })) out.add(isAbsolute(match) ? match : resolve(cwd, match));
-	return [...out].sort();
-}
-//#endregion
-//#region src/test-runner/bundle.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.
-*/
-/** The SDK package name that mini-app test code imports from. */
-const SDK_PACKAGE = "@apps-in-toss/web-framework";
-/**
-* Names the runtime installs as globals before invoking the user factory.
-* The `vitest` virtual module re-exports each as a lazy getter that reads from
-* `globalThis` at access time. Keep in sync with the globals installed in
-* `runtime.ts#runTestModule`.
-*/
-const VITEST_GLOBAL_NAMES = [
-	"describe",
-	"it",
-	"test",
-	"expect",
-	"beforeAll",
-	"afterAll",
-	"beforeEach",
-	"afterEach",
-	"vi"
-];
-/**
-* Matches the bare SDK package and any sub-path import
-* (`@apps-in-toss/web-framework`, `@apps-in-toss/web-framework/foo`).
-* Built from {@link SDK_PACKAGE} so the package name has a single source.
-*/
-const SDK_IMPORT_FILTER = new RegExp(`^${SDK_PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
-/**
-* esbuild plugin that intercepts SDK imports and redirects them to the
-* `window.__sdk` proxy that `src/in-app/auto.ts` installs at runtime.
-*
-* Strategy: for every import of `@apps-in-toss/web-framework` (or sub-paths),
-* esbuild resolves it to a virtual module that re-exports all named exports
-* via `window.__sdk[name]`. This avoids bundling the real SDK (which may not
-* be available in the test environment) while still making named imports work.
-*
-* If `window.__sdk` is absent (non-dog-food build), every access throws a
-* descriptive error rather than returning `undefined` silently.
-*/
-function sdkRedirectPlugin() {
-	return {
-		name: "sdk-redirect",
-		setup(build) {
-			build.onResolve({ filter: SDK_IMPORT_FILTER }, (args) => ({
-				path: args.path,
-				namespace: "sdk-redirect"
-			}));
-			build.onLoad({
-				filter: /.*/,
-				namespace: "sdk-redirect"
-			}, () => ({
-				contents: `
-var __proxy = (typeof window !== 'undefined' && window.__sdk)
-  ? window.__sdk
-  : new Proxy({}, {
-      get: function(_t, p) {
-        throw new Error('window.__sdk is not installed — run in a dog-food build. Missing: ' + String(p));
-      }
-    });
-module.exports = __proxy;
-`,
-				loader: "js"
-			}));
-		}
-	};
-}
-/**
-* esbuild plugin that intercepts `import … from 'vitest'` and replaces it with
-* a virtual module that delegates every named import to `globalThis` at ACCESS
-* time (not at bundle-evaluation time).
-*
-* The runtime installs `describe/it/test/expect/beforeAll/afterAll/beforeEach/
-* afterEach/vi` as globals inside `runTestModule`, which runs AFTER the bundle
-* IIFE is evaluated. A value-copy redirect (`export var describe =
-* globalThis.describe`) would therefore capture `undefined` at evaluation time
-* and the user's `describe(...)` calls would be no-ops — registering zero tests.
-*
-* The fix defers the lookup to call time using per-name **getter** exports.
-* We emit a CommonJS module that:
-*   1. sets `__esModule = true` so esbuild's `__toESM` interop maps each named
-*      import directly to a property access on the module (NOT wrapped under a
-*      `default` shim — which is what happens for a bare Proxy whose own-keys
-*      are empty, leaving every named import `undefined`);
-*   2. defines each global name as a getter that reads `globalThis[name]` on
-*      every access. So `import { describe } from 'vitest'` compiles to
-*      `import_vitest.describe`, whose getter returns the real `describe` only
-*      when the factory calls it — after `runTestModule` installs the globals.
-*
-* A plain `module.exports = new Proxy(...)` does NOT work here: esbuild routes
-* the virtual module through `__toESM`, which enumerates own-keys (none on an
-* empty Proxy target) and therefore exposes zero named exports. Explicit getter
-* properties give `__toESM` real keys to map while keeping access lazy.
-*/
-function vitestRedirectPlugin() {
-	return {
-		name: "vitest-redirect",
-		setup(build) {
-			build.onResolve({ filter: /^vitest$/ }, () => ({
-				path: "vitest",
-				namespace: "vitest-redirect"
-			}));
-			build.onLoad({
-				filter: /^vitest$/,
-				namespace: "vitest-redirect"
-			}, () => {
-				return {
-					contents: `Object.defineProperty(exports, '__esModule', { value: true });\n${VITEST_GLOBAL_NAMES.map((name) => `Object.defineProperty(exports, ${JSON.stringify(name)}, { enumerable: true, get: function() { return globalThis[${JSON.stringify(name)}]; } });`).join("\n")}\n`,
-					loader: "js"
-				};
-			});
-		}
-	};
-}
-/**
-* esbuild plugin that transforms the user test file into a module that exports
-* an async `__userFactory` function. The factory defers the user's top-level
-* test registration code (describe/it/test calls) so it only runs when
-* `runTestModule(__userFactory)` explicitly invokes it — AFTER the runtime has
-* installed describe/it/test/expect as globals.
-*
-* Algorithm:
-*   - Import declarations and re-export statements are kept at module top-level
-*     (the only valid ESM position for static `import`). A statement that spans
-*     multiple lines — e.g. a named import with one member per line:
-*       import {
-*         appLogin,
-*         getAnonymousKey,
-*       } from '@apps-in-toss/web-framework';
-*     is tracked as a single block: every line from the opening `import {` /
-*     `export {` through the closing `from '…'` (or side-effect `'…'`) line is
-*     kept together at top-level. This prevents the member lines and the
-*     closing `} from '…'` line from leaking into the factory body, which would
-*     leave an unterminated `import {` at module scope (the #678 env3 failure:
-*     esbuild threw `Expected "as" but found "{"` on multi-line SDK imports).
-*   - All other lines (describe/it/test calls, local declarations, etc.) are
-*     moved into the body of the exported async factory function.
-*
-* This preserves SDK import resolution (the sdk-redirect plugin processes
-* top-level imports normally) while deferring test registration to the factory.
-*/
-function userFactoryPlugin(absPath) {
-	const NAMESPACE = "user-test-factory";
-	return {
-		name: "user-test-factory",
-		setup(build) {
-			build.onResolve({ filter: /^user-test-factory$/ }, () => ({
-				path: absPath,
-				namespace: NAMESPACE
-			}));
-			build.onLoad({
-				filter: /.*/,
-				namespace: NAMESPACE
-			}, async (args) => {
-				const lines = (await fs.readFile(args.path, "utf8")).split("\n");
-				const topLevelLines = [];
-				const bodyLines = [];
-				const EXPORT_DECLARATION_RE = /^(export\s+)(default\s+|async\s+function\s+|function\s+|class\s+|const\s+|let\s+|var\s+)/;
-				const isImportStart = (trimmed) => trimmed.startsWith("import ") || trimmed.startsWith("import{") || trimmed.startsWith("import'") || trimmed.startsWith("import\"");
-				const endsStatement = (trimmed) => /['"]\s*;?\s*$/.test(trimmed.replace(/\/\/.*$/, "").trimEnd());
-				let inImportBlock = false;
-				for (const line of lines) {
-					const trimmed = line.trimStart();
-					const indent = line.slice(0, line.length - trimmed.length);
-					if (inImportBlock) {
-						topLevelLines.push(line);
-						if (endsStatement(trimmed)) inImportBlock = false;
-						continue;
-					}
-					if (isImportStart(trimmed)) {
-						topLevelLines.push(line);
-						if (!endsStatement(trimmed)) inImportBlock = true;
-					} else if (trimmed.startsWith("export ")) if (trimmed.match(EXPORT_DECLARATION_RE)) bodyLines.push(indent + trimmed.slice(7));
-					else {
-						topLevelLines.push(line);
-						if (/\bfrom\b/.test(trimmed) ? !endsStatement(trimmed) : trimmed.endsWith("{")) inImportBlock = true;
-					}
-					else bodyLines.push(line);
-				}
-				return {
-					contents: [
-						...topLevelLines,
-						"",
-						"// biome-ignore lint: generated factory wrapper",
-						"export default async function __userFactory(): Promise<void> {",
-						...bodyLines.map((l) => `  ${l}`),
-						"}"
-					].join("\n"),
-					loader: "ts",
-					resolveDir: path.dirname(absPath)
-				};
-			});
-		}
-	};
-}
-/**
-* Returns the absolute path to the test-runner runtime module.
-*
-* Searches candidates in priority order:
-*   1. Co-located `runtime.ts` / `runtime.js` — covers the source tree
-*      (tsx / ts-node) and the `dist/test-runner/` entry.
-*   2. `../test-runner/runtime.js` — covers the `dist/mcp/cli.js` entry,
-*      where `import.meta.url` resolves to `dist/mcp/` (a sibling directory
-*      of `dist/test-runner/`). Without this second candidate the MCP entry
-*      point would look for `dist/mcp/runtime.js`, which does not exist, and
-*      every `run_tests` call would fail with an esbuild "Could not resolve"
-*      error (#678).
-*
-* Returns the first candidate that exists on disk. Falls back to the
-* co-located `runtime.js` path so esbuild produces a clear "file not found"
-* error rather than a cryptic failure.
-*/
-function getRuntimePath() {
-	const dir = path.dirname(fileURLToPath(import.meta.url));
-	const candidates = [
-		path.join(dir, "runtime.ts"),
-		path.join(dir, "runtime.js"),
-		path.join(dir, "..", "test-runner", "runtime.js")
-	];
-	for (const candidate of candidates) try {
-		accessSync(candidate);
-		return candidate;
-	} catch {}
-	return path.join(dir, "runtime.js");
-}
-/**
-* Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.
-*
-* The IIFE installs `window.__testBundle` (or the custom `globalName`) with:
-*   - `runTestModule` — the runtime entry (from `runtime.ts`).
-*   - `__userFactory` — an async function wrapping the user's test registration
-*     code so it runs AFTER `runTestModule` installs the globals.
-*
-* Callers (rpc.ts) invoke:
-*   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
-*
-* @param absPath - Absolute path to the user test file.
-* @param opts    - Optional bundling overrides.
-*/
-async function bundleTestFile(absPath, opts) {
-	const globalName = opts?.globalName ?? "__testBundle";
-	const extraExternals = opts?.extraExternals ?? [];
-	const esbuild = await import("esbuild");
-	const runtimePath = getRuntimePath();
-	const wrapperContent = [
-		`import { runTestModule } from ${JSON.stringify(runtimePath)};`,
-		`import __userFactory from "user-test-factory";`,
-		`export { runTestModule, __userFactory };`
-	].join("\n");
-	const result = await esbuild.build({
-		stdin: {
-			contents: wrapperContent,
-			loader: "ts",
-			resolveDir: path.dirname(absPath)
-		},
-		bundle: true,
-		format: "iife",
-		globalName,
-		platform: "browser",
-		target: "es2022",
-		write: false,
-		plugins: [
-			userFactoryPlugin(absPath),
-			vitestRedirectPlugin(),
-			sdkRedirectPlugin()
-		],
-		external: extraExternals,
-		treeShaking: true,
-		footer: { js: `globalThis[${JSON.stringify(globalName)}] = ${globalName};` }
-	});
-	const warnings = result.warnings.map((w) => `${path.relative(process.cwd(), w.location?.file ?? "")}:${w.location?.line ?? "?"}: ${w.text}`);
-	const outputFile = result.outputFiles?.[0];
-	if (!outputFile) throw new Error("bundleTestFile: esbuild produced no output — check entryPoints");
-	return {
-		code: outputFile.text,
-		warnings
-	};
-}
-//#endregion
-//#region src/test-runner/rpc.ts
-/** Maximum milliseconds to wait for a single evaluate round-trip. */
-const DEFAULT_TIMEOUT_MS = 3e4;
-/**
-* Wraps bundle code in a self-executing IIFE that:
-*   1. Evaluates the bundle (registering describe/it/test).
-*   2. Calls `__testBundle.runTestModule(...)` — the entry the runtime exports.
-*   3. Returns a JSON-serialised `RunReport` string.
-*
-* The double-serialisation (RunReport → JSON string → returnByValue string)
-* is intentional: CDP `returnByValue` reliably transports strings; deeply
-* nested objects can lose fidelity across the Chii relay.
-*
-* SECRET-HANDLING: `bundleCode` MUST NOT be logged by callers.
-*/
-function buildRunTestsExpression(bundleCode) {
-	return `(async () => {  try { ${bundleCode} } catch(e) {    return JSON.stringify({ok:false,error:'bundle-eval: ' + String(e && e.message || e)});  }  if (typeof globalThis.__testBundle !== 'object' || typeof globalThis.__testBundle.runTestModule !== 'function' || typeof globalThis.__testBundle.__userFactory !== 'function') {    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule or __userFactory is not a function'});  }  try {    const report = await globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory);    return JSON.stringify({ok:true,value:report});  } catch(e) {    return JSON.stringify({ok:false,error:'test-run: ' + String(e && e.message || e)});  }})()`;
-}
-/**
-* Parses the raw CDP `returnByValue` result from a `buildRunTestsExpression`
-* evaluate call into a typed `RpcRunResult`.
-*
-* Throws only on parse failure — an `ok:false` envelope is a normal result.
-*
-* SECRET-HANDLING: `rawValue` is not included in error messages.
-*/
-function parseRunTestsResult(rawValue) {
-	if (typeof rawValue !== "string") throw new Error(`rpc.parseRunTestsResult: unexpected return type "${typeof rawValue}" — expected JSON string`);
-	let parsed;
-	try {
-		parsed = JSON.parse(rawValue);
-	} catch {
-		throw new Error("rpc.parseRunTestsResult: bridge returned non-JSON string");
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("rpc.parseRunTestsResult: parsed result is not an object");
-	const obj = parsed;
-	if (obj.ok === true) return {
-		ok: true,
-		report: obj.value
-	};
-	if (obj.ok === false) return {
-		ok: false,
-		error: typeof obj.error === "string" ? obj.error : String(obj.error)
-	};
-	throw new Error("rpc.parseRunTestsResult: result missing \"ok\" field");
-}
-/**
-* Injects `bundleCode` into the attached page and awaits test execution.
-*
-* Uses `Runtime.evaluate` with `awaitPromise: true` to wait for the
-* async IIFE to settle.  The 30-second CDP command timeout covers even
-* long-running test suites; split into smaller files if you hit it.
-*
-* @param connection   - Active CDP connection (relay or local).
-* @param bundleCode   - IIFE bundle string from `bundleTestFile`.
-* @param timeoutMs    - Override the default 30 s timeout.
-*
-* SECRET-HANDLING: `bundleCode` and the raw CDP result value are never logged.
-*/
-async function injectAndRunBundle(connection, bundleCode, timeoutMs = DEFAULT_TIMEOUT_MS) {
-	const expression = buildRunTestsExpression(bundleCode);
-	const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`rpc: evaluate timed out after ${timeoutMs}ms`)), timeoutMs));
-	const evalPromise = connection.send("Runtime.evaluate", {
-		expression,
-		returnByValue: true,
-		awaitPromise: true
-	});
-	const cdpResult = await Promise.race([evalPromise, timeoutPromise]);
-	if (cdpResult.exceptionDetails) {
-		const msg = cdpResult.exceptionDetails.exception?.description ?? cdpResult.exceptionDetails.text ?? "Runtime.evaluate threw an exception";
-		throw new Error(`rpc.injectAndRunBundle: ${msg}`);
-	}
-	return parseRunTestsResult(cdpResult.result.value);
-}
-//#endregion
-//#region src/test-runner/relay-worker.ts
-/**
-* Runs all `files` sequentially over the given CDP `connection`.
-*
-* For each file:
-*   1. Bundle with esbuild (includes SDK shim + runtime).
-*   2. Inject into the attached page via `Runtime.evaluate`.
-*   3. Await the `RunReport` JSON response.
-*   4. Accumulate results.
-*
-* Returns a `RelayRunReport` with per-file results and flattened totals.
-*
-* This function does NOT open or manage the relay connection — the caller
-* is responsible for attaching and closing it.
-*
-* TODO (#645): implement the Vitest `PoolRunnerInitializer` interface here
-* so that `runTestFilesOverRelay` can be used as a Vitest pool entry.
-*
-* @param connection - Active CDP connection (relay or local kind).
-* @param files      - Absolute paths to test files, run in order.
-* @param opts       - Optional per-run overrides.
-*/
-async function runTestFilesOverRelay(connection, files, opts) {
-	const wallStart = Date.now();
-	const startedAt = new Date(wallStart).toISOString();
-	const fileResults = [];
-	for (const file of files) {
-		let fileEntry;
-		try {
-			const { code } = await bundleTestFile(file, opts?.bundleOptions);
-			const rpcResult = await injectAndRunBundle(connection, code, opts?.timeoutMs);
-			if (rpcResult.ok) fileEntry = {
-				file,
-				result: rpcResult.report
-			};
-			else fileEntry = {
-				file,
-				result: { error: rpcResult.error }
-			};
-		} catch (e) {
-			fileEntry = {
-				file,
-				result: { error: e instanceof Error ? e.message : String(e) }
-			};
-		}
-		fileResults.push(fileEntry);
-	}
-	const totals = fileResults.reduce((acc, { result }) => {
-		if ("error" in result) {
-			acc.failed += 1;
-			acc.total += 1;
-		} else {
-			acc.passed += result.passed;
-			acc.failed += result.failed;
-			acc.skipped += result.skipped;
-			acc.total += result.passed + result.failed + result.skipped;
-		}
-		return acc;
-	}, {
-		passed: 0,
-		failed: 0,
-		skipped: 0,
-		total: 0
-	});
-	return {
-		startedAt,
-		duration: Date.now() - wallStart,
-		files: fileResults,
-		totals
-	};
-}
-//#endregion
-//#region src/test-runner/cli.ts
-/**
-* `devtools-test` CLI.
-*
-* Shares test-file discovery with the `run_tests` MCP tool (`discoverTestFiles`)
-* and exposes `runWithConnection` — the pure run core that bundles, injects, and
-* collects each file over a CDP connection. Today the run path that has a live
-* connection is the `run_tests` MCP tool (it runs these files against the
-* daemon's attached page); the CLI's own standalone relay attach (resolve CDP
-* URL → attach → run → close) is not wired yet, so `main()` resolves the matched
-* files and points the operator at the MCP tool.
-*
-* NOTE: no shebang in this source file — the tsdown entry's `banner` option
-* injects `#!/usr/bin/env node` into the compiled output (same pattern as
-* `src/mcp/cli.ts`).
-*/
-const USAGE = `
-devtools-test — run mini-app tests on a real device WebView over the CDP relay
-
-USAGE
-  devtools-test <glob> [<glob> ...] [options]
-
-OPTIONS
-  --timeout <ms>    Per-file evaluate timeout in ms (default: 30000)
-  --help, -h        Show this help message
-
-DESCRIPTION
-  Bundles each matched test file with esbuild (SDK imports redirected to
-  window.__sdk), injects the bundle into the attached WebView via
-  Runtime.evaluate, and returns a RunReport.
-
-  A live CDP relay connection must be active before running tests. Use the
-  \`run_tests\` MCP tool (via \`devtools-mcp\` / \`/ait debug\`) to run these files
-  against an attached page — the CLI's own standalone relay attach is not wired
-  yet (it currently resolves the matched files and defers to that tool).
-
-EXAMPLE
-  devtools-test 'src/**/*.ait.test.ts' --timeout 60000
-
-`.trimStart();
-/**
-* 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.
-*
-* A standalone CLI relay attach/detach lifecycle (connect via Chii relay URL,
-* `enableDomains`, run, then close) is not wired into `main()` yet.
-*/
-async function runWithConnection(connection, files, opts) {
-	const report = await runTestFilesOverRelay(connection, files, opts);
-	if (opts?.printSummary) {
-		const { totals } = report;
-		process.stdout.write(`\ndevtools-test: ${totals.passed} passed, ${totals.failed} failed, ${totals.skipped} skipped (${report.duration}ms)\n`);
-	}
-	return report;
-}
-/**
-* CLI entry point.
-*
-* Resolves the matched test files and prints a "relay attach required" notice:
-* the CLI's own standalone relay attach (resolve CDP URL, attach, run, close) is
-* not wired yet, so today these files run via the `run_tests` MCP tool against
-* the daemon's attached page.
-*/
-async function main(argv = process.argv.slice(2)) {
-	let parsed;
-	try {
-		parsed = parseArgs({
-			args: argv,
-			options: {
-				help: {
-					type: "boolean",
-					short: "h"
-				},
-				timeout: { type: "string" }
-			},
-			allowPositionals: true
-		});
-	} catch (e) {
-		process.stderr.write(`devtools-test: ${e instanceof Error ? e.message : String(e)}\n`);
-		process.exitCode = 1;
-		return;
-	}
-	if (parsed.values.help || argv.length === 0) {
-		process.stdout.write(USAGE);
-		return;
-	}
-	const files = await discoverTestFiles(parsed.positionals, process.cwd());
-	if (files.length === 0) {
-		process.stderr.write(`devtools-test: no test files matched ${parsed.positionals.join(", ")}\n`);
-		process.exitCode = 1;
-		return;
-	}
-	process.stderr.write(`devtools-test: matched ${files.length} test file(s), but direct CLI relay attach is not yet wired.\n  Use the devtools-mcp server (\`devtools-mcp\`) to start a debug session,\n  then the \`run_tests\` MCP tool to run these files against the attached page.\n`);
-	process.exitCode = 1;
-}
-if (import.meta.url === new URL(process.argv[1], "file://").href) main().catch((e) => {
-	process.stderr.write(`devtools-test: unexpected error: ${e instanceof Error ? e.message : String(e)}\n`);
-	process.exitCode = 1;
-});
-//#endregion
+import { n as runWithConnection, t as main } from "../cli-BLBo0lkP.js";
 export { main, runWithConnection };
-
-//# sourceMappingURL=cli.js.map

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

@@ -1,4 +1,4 @@
-import { i as createRelayPool, n as RelayConnectionFactory, t as RELAY_POOL_NAME } from "../pool-D23t4ibd.js";
+import { i as createRelayPool, n as RelayConnectionFactory, t as RELAY_POOL_NAME } from "../pool-htlVnEFl.js";
 
 //#region src/test-runner/config.d.ts
 /**

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

@@ -1,2 +1,2 @@
-import { i as createRelayPool, n as RelayConnectionFactory, r as RelayPoolOptions, t as RELAY_POOL_NAME } from "../pool-D23t4ibd.js";
+import { i as createRelayPool, n as RelayConnectionFactory, r as RelayPoolOptions, t as RELAY_POOL_NAME } from "../pool-htlVnEFl.js";
 export { RELAY_POOL_NAME, RelayConnectionFactory, RelayPoolOptions, createRelayPool };

package/dist/test-runner/relay-worker.d.ts

@@ -1,2 +1,2 @@
-import { a as runTestFilesOverRelay, i as flattenResults, n as RelayRunOptions, r as RelayRunReport, t as FileResult } from "../relay-worker-DERQUao2.js";
+import { a as runTestFilesOverRelay, i as flattenResults, n as RelayRunOptions, r as RelayRunReport, t as FileResult } from "../relay-worker-DWW4vZxU.js";
 export { FileResult, RelayRunOptions, RelayRunReport, flattenResults, runTestFilesOverRelay };

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

@@ -1,5 +1,5 @@
 import { t as CdpConnection } from "../cdp-connection-C0AP0tH2.js";
-import { t as RunReport } from "../runtime-BKMMoeMj.js";
+import { t as RunReport } from "../runtime-BU-iMHz6.js";
 
 //#region src/test-runner/rpc.d.ts
 /**

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

@@ -1,2 +1,2 @@
-import { i as runtimeGlobals, n as TestResult, r as runTestModule, t as RunReport } from "../runtime-BKMMoeMj.js";
+import { i as runtimeGlobals, n as TestResult, r as runTestModule, t as RunReport } from "../runtime-BU-iMHz6.js";
 export { RunReport, TestResult, runTestModule, runtimeGlobals };