@ait-co/devtools 0.1.106 → 0.1.108

package/dist/mcp/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { i as generateTotp, n as assertRelayAuthConfigured, r as buildRelayVerifyAuth } from "../totp-Xq3ACwkm.js";
-import { t as loadRelaySecretReadOnly } from "../relay-secret-store-B0DH-8Qb.js";
+import { i as generateTotp, n as assertRelayAuthConfigured, r as buildRelayVerifyAuth } from "../totp-WY6l0ysP.js";
+import { t as loadRelaySecretReadOnly } from "../relay-secret-store-DhzAnnj-.js";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { argv } from "node:process";
@@ -8,6 +8,10 @@ import { fileURLToPath } from "node:url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { parseArgs } from "node:util";
+import { glob } from "node:fs/promises";
+import * as path from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { EventEmitter } from "node:events";
 import { WebSocket, WebSocketServer } from "ws";
 import { randomBytes } from "node:crypto";
@@ -15,7 +19,6 @@ import { createServer } from "node:http";
 import { spawn } from "node:child_process";
 import net from "node:net";
 import { homedir, platform } from "node:os";
-import { join } from "node:path";
 import { Tunnel, bin, install } from "cloudflared";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -119,6 +122,375 @@ function startMaxAgeWatchdog(onExpired, opts = {}) {
 	} };
 }
 //#endregion
+//#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/**\/*.phone.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 user's SDK imports
+* (`@apps-in-toss/web-framework` and sub-paths) are intercepted via an
+* esbuild plugin that redirects them to `window.__sdk`, which the in-app
+* debug gate (`src/in-app/auto.ts`) installs as a namespace mirror of the
+* SDK exports (works for both 2.x and 3.x SDK).
+*
+* SECRET-HANDLING: the returned bundle code is caller-managed; never log it.
+*/
+/**
+* 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(`^${"@apps-in-toss/web-framework".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"
+			}));
+		}
+	};
+}
+/**
+* Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.
+*
+* The IIFE installs `window.__testBundle` (or the custom `globalName`) with
+* `runTestModule` as the callable entry point.
+*
+* @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 result = await (await import("esbuild")).build({
+		entryPoints: [absPath],
+		bundle: true,
+		format: "iife",
+		globalName,
+		platform: "browser",
+		target: "es2022",
+		write: false,
+		plugins: [sdkRedirectPlugin()],
+		external: extraExternals,
+		treeShaking: true
+	});
+	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') {    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule is not a function'});  }  try {    const report = await globalThis.__testBundle.runTestModule();    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 — MVP skeleton.
+*
+* Parses argv, prints usage, and delegates to `runTestFilesOverRelay` when
+* a live CDP connection is provided. The relay connection wiring
+* (attach → run → detach) is tracked in issue #645 / #646.
+*
+* MVP contract: `--help` works, `runWithConnection` is a testable pure
+* function, and the binary entry exists in package.json.
+*
+* 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 \`/ait debug\` (devtools-mcp) to attach and then call this CLI from
+  the same process context.
+
+  Full Vitest pool integration and the \`run_tests\` MCP tool are tracked in
+  issues #645 and #646 respectively. This MVP provides the transport layer.
+
+EXAMPLE
+  devtools-test 'src/**/*.phone.test.ts' --timeout 60000
+
+`.trimStart();
+/**
+* Runs `files` over `connection` and returns the aggregate report.
+* This pure function is the testable core of the CLI; it is separate from
+* `main()` so tests can call it without spawning a subprocess.
+*
+* TODO (#645): add real relay attach/detach lifecycle here (connect via
+* Chii relay URL, call enableDomains, run, then close).
+*/
+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.
+*
+* MVP: prints usage and a "relay attach required" notice. Real relay wiring
+* (resolve CDP URL, attach, run, close) is tracked in issues #645 / #646.
+*/
+async function main$1(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  Direct CLI relay wiring is tracked in issue #645.\n`);
+	process.exitCode = 1;
+}
+if (import.meta.url === new URL(process.argv[1], "file://").href) main$1().catch((e) => {
+	process.stderr.write(`devtools-test: unexpected error: ${e instanceof Error ? e.message : String(e)}\n`);
+	process.exitCode = 1;
+});
+//#endregion
 //#region src/mcp/ait-chii-source.ts
 function isObject$4(value) {
 	return typeof value === "object" && value !== null;
@@ -213,7 +585,11 @@ const ALLOWED_KEYS = new Set([
 	"errorKind",
 	"reason",
 	"prevTargetId",
-	"mode"
+	"mode",
+	"fileCount",
+	"passed",
+	"failed",
+	"skipped"
 ]);
 /**
 * Patterns that match secret values.
@@ -4033,6 +4409,34 @@ const DEBUG_TOOL_DEFINITIONS = [
 			required: []
 		},
 		availableIn: "both"
+	},
+	{
+		name: "run_tests",
+		description: "Runs mini-app test files on the attached page over CDP (Runtime.evaluate). Each matched file is bundled with esbuild (SDK imports redirected to the live mock/SDK), injected into the attached WebView, and executed; returns per-file results plus flattened totals (passed/failed/skipped/total). Requires an attached page — call list_pages first to confirm one is attached. Files run SEQUENTIALLY (single-attach model: the relay/local target serves one page), and one run_tests call runs at a time (a concurrent call is rejected). Test verification (assert/snapshot) is delegated to the in-page Vitest runtime; this tool is the transport + report. The per-file results array is the progress record — on partial failure you see exactly which files passed/failed/timed-out. In a relay-live session this is a state-mutating injection and is blocked unless confirm=true (ignored in mock/local/relay-dev/relay-mobile). debug-mode only — dev-mode (--mode=dev) has no CDP. Tier C (both mock/local and relay). Use the test-runner CLI (devtools-test) for the same run outside MCP.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				files: {
+					type: "array",
+					items: { type: "string" },
+					description: "Glob patterns or file paths to run (e.g. [\"src/**/*.phone.test.ts\"]). Resolved relative to projectRoot when given, else the daemon cwd. Required, non-empty."
+				},
+				projectRoot: {
+					type: "string",
+					description: "Absolute path to the mini-app project root used as the glob base. Pass this because the daemon's cwd is fixed at launch. Optional."
+				},
+				timeout_ms: {
+					type: "number",
+					description: "Per-file evaluate timeout in ms (default 30000, range 1000–600000). Out-of-range/invalid values fall back to the default."
+				},
+				confirm: {
+					type: "boolean",
+					description: "Required (true) to run in a relay-live session — test injection mutates page state. Ignored in mock/local/relay-dev/relay-mobile sessions."
+				}
+			},
+			required: ["files"]
+		},
+		availableIn: "both"
 	}
 ];
 const DEBUG_TOOL_NAMES = new Set(DEBUG_TOOL_DEFINITIONS.map((t) => t.name));
@@ -4855,7 +5259,7 @@ async function readMcpSdkVersion() {
 * some test environments that skip the build step).
 */
 function readDevtoolsVersion() {
-	return "0.1.106";
+	return "0.1.108";
 }
 /**
 * Derives the next recommended action from a completed diagnostics snapshot.
@@ -5385,6 +5789,16 @@ function isRelayMode(mode) {
 	return mode === "relay-sandbox" || mode === "relay-staging" || mode === "relay-live";
 }
 /**
+* Single-attach guard for `run_tests` (#646). Two concurrent runs injecting
+* into the same single-attach page would interleave `Runtime.evaluate` and
+* corrupt each other's `globalThis.__testBundle`. The model is "reject the
+* second", not "queue" — a module-level flag is process-wide, which matches the
+* single physical attached page (only one target is live at a time). The
+* entry-time `conn` snapshot ensures a run finishes on the connection it started
+* on even if `router.active` flips mid-run.
+*/
+let runTestsInFlight = false;
+/**
 * Waits for the first target matching `filterFn` to attach, using the
 * event-driven `waitForFirstTarget()` when the connection supports it
 * (interface-optional member, present on `ChiiCdpConnection`), or falling
@@ -5447,7 +5861,7 @@ function createDebugServer(deps) {
 	const collector = collectorDep ?? new InMemoryDiagnosticsCollector();
 	const server = new Server({
 		name: "ait-debug",
-		version: "0.1.106"
+		version: "0.1.108"
 	}, { capabilities: { tools: { listChanged: true } } });
 	server.setRequestHandler(ListToolsRequestSchema, () => {
 		const conn = router.active;
@@ -5535,7 +5949,7 @@ function createDebugServer(deps) {
 				const buildProjectRoot = typeof rawBuildProjectRoot === "string" ? rawBuildProjectRoot : void 0;
 				let tunnelHttpUrl = process.env.AIT_TUNNEL_BASE_URL?.trim() ?? "";
 				if (tunnelHttpUrl === "" && buildProjectRoot !== void 0) {
-					const { readRelayUrls } = await import("../relay-url-store-BPeUZsiY.js");
+					const { readRelayUrls } = await import("../relay-url-store-CwKT7i04.js");
 					tunnelHttpUrl = (await readRelayUrls({ projectRoot: buildProjectRoot }))?.tunnelBaseUrl ?? "";
 				}
 				if (tunnelHttpUrl === "") return mcpError("build_attach_url(mobile): AIT_TUNNEL_BASE_URL이 설정되지 않았습니다. dev 서버가 tunnel:{cdp:true}로 기동 중이면 .ait_urls 파일이 자동 생성돼 있어야 합니다. 자동 발견이 되지 않을 경우 앱 HTTP 터널 URL을 AIT_TUNNEL_BASE_URL 환경변수로 직접 전달하세요.");
@@ -5950,6 +6364,35 @@ ${browserResult.httpUrl}\n또는 PNG로 받기: ${browserResult.pngUrl}` + stder
 					if (!sdkResult.ok && typeof sdkResult.error === "string" && sdkResult.error.startsWith("sdk-absent:")) return sdkAbsentError("call_sdk", conn.kind === "local");
 					return envelopeResult$1(sdkResult, name, env, conn.listTargets().length > 0);
 				}
+				case "run_tests": {
+					const rawFiles = request.params.arguments?.files;
+					if (!Array.isArray(rawFiles) || rawFiles.length === 0) return mcpError("run_tests: files 인자가 비어 있습니다. 실행할 테스트 파일 glob을 배열로 전달하세요.");
+					const patterns = rawFiles.filter((p) => typeof p === "string" && p !== "");
+					if (patterns.length === 0) return mcpError("run_tests: files 인자에 유효한 문자열 glob이 없습니다.");
+					const rawRoot = request.params.arguments?.projectRoot;
+					const projectRoot = typeof rawRoot === "string" ? rawRoot : process.cwd();
+					const rawTimeout = request.params.arguments?.timeout_ms;
+					const timeoutMs = typeof rawTimeout === "number" && rawTimeout >= 1e3 && rawTimeout <= 6e5 ? rawTimeout : void 0;
+					if (conn.kind === "relay" && getLiveIntent() && request.params.arguments?.confirm !== true) return liveGuardError("run_tests");
+					if (runTestsInFlight) return mcpError("run_tests: 이미 다른 테스트 실행이 진행 중입니다 (single-attach 모델: 페이지는 한 번에 하나의 실행만 처리). 완료 후 다시 시도하세요.");
+					runTestsInFlight = true;
+					try {
+						const files = await discoverTestFiles(patterns, projectRoot);
+						if (files.length === 0) return mcpError(`run_tests: 매칭된 테스트 파일이 없습니다 (patterns: ${patterns.join(", ")}).`);
+						if (conn.listTargets().length === 0) return pageMissingError("run_tests");
+						logInfo("run_tests.start", { fileCount: files.length });
+						const report = await runWithConnection(conn, files, { timeoutMs });
+						logInfo("run_tests.done", {
+							passed: report.totals.passed,
+							failed: report.totals.failed,
+							skipped: report.totals.skipped
+						});
+						const runAttached = conn.listTargets().length > 0;
+						return envelopeResult$1(toRunTestsResult(report), name, env, runAttached);
+					} finally {
+						runTestsInFlight = false;
+					}
+				}
 				default: return unknownTool(name);
 			}
 		} catch (err) {
@@ -6035,6 +6478,30 @@ function envelopeResult$1(value, tool, env, attached) {
 		text: JSON.stringify(wrapped, null, 2)
 	}] };
 }
+/**
+* Maps a {@link RelayRunReport} to a flat, agent-friendly object for the
+* `run_tests` tool result. SECRET-HANDLING: a RelayRunReport carries only
+* startedAt/duration/totals and per-file `{file, result}` — file paths are
+* surfaced (allowed), relay wss/TOTP URLs never appear in it. No stripping
+* needed; this only reshapes for readability.
+*/
+function toRunTestsResult(report) {
+	return {
+		startedAt: report.startedAt,
+		duration: report.duration,
+		totals: report.totals,
+		files: report.files.map((f) => "error" in f.result ? {
+			file: f.file,
+			error: f.result.error
+		} : {
+			file: f.file,
+			passed: f.result.passed,
+			failed: f.result.failed,
+			skipped: f.result.skipped,
+			tests: f.result.tests
+		})
+	};
+}
 function unknownTool(name) {
 	return mcpError(`알 수 없는 tool: ${name}`);
 }
@@ -6289,7 +6756,7 @@ async function readRelayLocalUrl(env = process.env, projectRoot) {
 	const envValue = (env.AIT_RELAY_LOCAL_URL ?? "").trim();
 	if (envValue !== "") return envValue;
 	if (projectRoot !== void 0) try {
-		const { readRelayUrls } = await import("../relay-url-store-BPeUZsiY.js");
+		const { readRelayUrls } = await import("../relay-url-store-CwKT7i04.js");
 		const stored = await readRelayUrls({ projectRoot });
 		if (stored?.relayLocalUrl) return stored.relayLocalUrl;
 	} catch {}
@@ -6343,7 +6810,7 @@ async function readMobileRelayBaseUrl(env = process.env, projectRoot) {
 	const envValue = typeof raw === "string" ? raw.trim() : "";
 	if (envValue !== "") return envValue;
 	if (projectRoot !== void 0) {
-		const { readRelayUrls } = await import("../relay-url-store-BPeUZsiY.js");
+		const { readRelayUrls } = await import("../relay-url-store-CwKT7i04.js");
 		const stored = await readRelayUrls({ projectRoot });
 		if (stored?.relayBaseUrl !== void 0) return stored.relayBaseUrl;
 	}
@@ -7456,6 +7923,34 @@ const DEV_TOOL_DEFINITIONS = [
 			required: []
 		},
 		availableIn: "both"
+	},
+	{
+		name: "run_tests",
+		description: "Runs mini-app test files on the attached page over CDP (Runtime.evaluate). NOT available in dev-mode (no CDP connection). Switch to `--mode=local` or `--mode=debug`.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				files: {
+					type: "array",
+					items: { type: "string" },
+					description: "Glob patterns or file paths to run."
+				},
+				projectRoot: {
+					type: "string",
+					description: "Glob base directory."
+				},
+				timeout_ms: {
+					type: "number",
+					description: "Per-file evaluate timeout in ms."
+				},
+				confirm: {
+					type: "boolean",
+					description: "Required in relay-live sessions."
+				}
+			},
+			required: ["files"]
+		},
+		availableIn: "both"
 	}
 ];
 /** All tool names served in dev-mode (including tier-filter stubs). */
@@ -7468,7 +7963,8 @@ const CDP_ONLY_TOOL_NAMES = new Set([
 	"take_snapshot",
 	"list_console_messages",
 	"list_network_requests",
-	"list_exceptions"
+	"list_exceptions",
+	"run_tests"
 ]);
 /**
 * Tier B tools — relay-only per RFC #277.
@@ -7585,7 +8081,7 @@ function createDevServer(deps = {}) {
 	const aitSource = deps.aitSource ?? new HttpAitSource({ stateEndpoint });
 	const server = new Server({
 		name: "ait-devtools",
-		version: "0.1.106"
+		version: "0.1.108"
 	}, { capabilities: { tools: {} } });
 	server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: DEV_TOOL_DEFINITIONS.map((tool) => ({ ...tool })) }));
 	server.setRequestHandler(CallToolRequestSchema, async (request) => {