@ait-co/devtools 0.1.126 → 0.1.127

package/dist/{relay-worker-7biDlEjo.d.ts → relay-worker-TReZtzGl.d.ts}

@@ -64,6 +64,14 @@ interface RelayRunOptions {
    */
   collectCaptures?: boolean;
 }
+/**
+ * Sentinel string embedded in the error message by `injectAndRunBundle` when
+ * the per-file evaluate race hits the timeout. Used by the retry guard so only
+ * genuine timeouts get a second attempt — not bundle errors or parse failures.
+ *
+ * Exported for unit tests that assert the retry path is taken.
+ */
+declare const EVALUATE_TIMEOUT_MARKER = "rpc: evaluate timed out after";
 /**
  * Runs all `files` sequentially over the given CDP `connection`.
  *
@@ -94,5 +102,5 @@ declare function flattenResults(report: RelayRunReport): Array<TestResult & {
   file: string;
 }>;
 //#endregion
-export { runTestFilesOverRelay as a, flattenResults as i, RelayRunOptions as n, RelayRunReport as r, FileResult as t };
-//# sourceMappingURL=relay-worker-7biDlEjo.d.ts.map
+export { flattenResults as a, RelayRunReport as i, FileResult as n, runTestFilesOverRelay as o, RelayRunOptions as r, EVALUATE_TIMEOUT_MARKER as t };
+//# sourceMappingURL=relay-worker-TReZtzGl.d.ts.map

package/dist/relay-worker-TReZtzGl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-worker-TReZtzGl.d.ts","names":[],"sources":["../src/test-runner/relay-worker.ts"],"mappings":";;;;;;;UAwBiB,UAAA;EAcf;EAZA,IAAA;EAcA;EAZA,MAAA,EAAQ,SAAA;IAAc,KAAA;EAAA;AAAA;;UAIP,cAAA;EAwBS;EAtBxB,SAAA;EA0Be;EAxBf,QAAA;;EAEA,KAAA,EAAO,UAAA;EA0BP;EAxBA,MAAA;IACE,MAAA;IACA,MAAA;IACA,OAAA;IACA,KAAA;EAAA;EA+CgC;;;;AAuBpC;;;;;;EA1DE,QAAA,EAAU,cAAA;AAAA;;UAIK,eAAA;EAuDf;;;EAnDA,aAAA,GAAgB,aAAA;EAsDf;;;;EAjDD,SAAA;EAoP4B;;;;;;;;;;;EAxO5B,eAAA;AAAA;;;;;;;;cAUW,uBAAA;;;;;;;;;;;;;;;;;;;;;;iBAuBS,qBAAA,CACpB,UAAA,EAAY,aAAA,EACZ,KAAA,YACA,IAAA,GAAO,eAAA,GACN,OAAA,CAAQ,cAAA;;;;;iBAmMK,cAAA,CAAe,MAAA,EAAQ,cAAA,GAAiB,KAAA,CAAM,UAAA;EAAe,IAAA;AAAA"}

package/dist/test-runner/bin.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
+import * as path$1 from "node:path";
+import path, { basename, isAbsolute, resolve } from "node:path";
 import { parseArgs } from "node:util";
 import * as fs from "node:fs/promises";
 import { glob, mkdir, writeFile } from "node:fs/promises";
-import * as path$1 from "node:path";
-import path, { isAbsolute, resolve } from "node:path";
 import { accessSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/test-runner/discover.ts
@@ -624,6 +624,14 @@ async function injectAndRunBundle(connection, bundleCode, timeoutMs = DEFAULT_TI
 //#endregion
 //#region src/test-runner/relay-worker.ts
 /**
+* Sentinel string embedded in the error message by `injectAndRunBundle` when
+* the per-file evaluate race hits the timeout. Used by the retry guard so only
+* genuine timeouts get a second attempt — not bundle errors or parse failures.
+*
+* Exported for unit tests that assert the retry path is taken.
+*/
+const EVALUATE_TIMEOUT_MARKER = "rpc: evaluate timed out after";
+/**
 * Runs all `files` sequentially over the given CDP `connection`.
 *
 * For each file:
@@ -666,15 +674,49 @@ async function runTestFilesOverRelay(connection, files, opts) {
 			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 }
+				/**
+				* Runs one evaluate attempt and returns a FileResult, or `null` when the
+				* result is a genuine timeout and the caller should retry.
+				*
+				* We need to distinguish:
+				*   - `rpcResult.ok = false` + timeout error → retry candidate
+				*   - `rpcResult.ok = false` + other error   → final error, no retry
+				*   - `injectAndRunBundle` throws             → treated like a final error
+				*     (throws happen on CDP exceptionDetails, not on the Promise.race
+				*     timeout — the timeout produces `rpcResult.ok=false` with the
+				*     EVALUATE_TIMEOUT_MARKER message)
+				*/
+				const attempt = async () => {
+					let rpcResult;
+					try {
+						rpcResult = await injectAndRunBundle(connection, code, opts?.timeoutMs);
+					} catch (e) {
+						return {
+							file,
+							result: { error: e instanceof Error ? e.message : String(e) }
+						};
+					}
+					if (rpcResult.ok) return {
+						file,
+						result: rpcResult.report
+					};
+					if (rpcResult.error.includes("rpc: evaluate timed out after")) return null;
+					return {
+						file,
+						result: { error: rpcResult.error }
+					};
 				};
+				const firstResult = await attempt();
+				if (firstResult !== null) fileEntry = firstResult;
+				else {
+					process.stderr.write(`relay-worker: evaluate timed out for ${file} — retrying once\n`);
+					const retryResult = await attempt();
+					if (retryResult !== null) fileEntry = retryResult;
+					else fileEntry = {
+						file,
+						result: { error: `${EVALUATE_TIMEOUT_MARKER} ${opts?.timeoutMs ?? 3e4}ms (after retry)` }
+					};
+				}
 			} catch (e) {
 				fileEntry = {
 					file,
@@ -961,6 +1003,42 @@ function resolveTimeouts(rawTimeout, rawAttachTimeout) {
 	};
 }
 /**
+* Renders per-file result lines and the aggregate totals line to a string.
+*
+* Each file gets one line:
+*   - Error/timeout:  `FAIL <basename>: <error-class>`
+*   - Pass (0 tests): `OK   <basename>: 0 passed (empty file)`
+*   - Pass:           `OK   <basename>: N passed[, M failed][, K skipped]`
+*
+* The aggregate totals line always follows.
+*
+* SECRET-HANDLING: only `basename(file)` is used — no absolute paths, relay
+* URLs, wss URLs, scheme URLs, or TOTP codes appear in the output. The error
+* string comes from `result.error` which is already secret-free (relay-worker
+* produces only error-class messages like "rpc: evaluate timed out after
+* 30000ms").
+*
+* Exported so unit tests can assert the per-file lines without spawning a
+* subprocess or going through the full relay attach flow.
+*/
+function renderSummary(report) {
+	const lines = [];
+	for (const { file, result } of report.files) {
+		const name = basename(file);
+		if ("error" in result) lines.push(`FAIL ${name}: ${result.error}`);
+		else {
+			const parts = [`${result.passed} passed`];
+			if (result.failed > 0) parts.push(`${result.failed} failed`);
+			if (result.skipped > 0) parts.push(`${result.skipped} skipped`);
+			const suffix = result.passed + result.failed + result.skipped === 0 ? " (empty file)" : "";
+			lines.push(`OK   ${name}: ${parts.join(", ")}${suffix}`);
+		}
+	}
+	const { totals, duration } = report;
+	lines.push(`\ndevtools-test: ${totals.passed} passed, ${totals.failed} failed, ${totals.skipped} skipped (${duration}ms)`);
+	return lines.join("\n");
+}
+/**
 * 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
@@ -968,10 +1046,7 @@ function resolveTimeouts(rawTimeout, rawAttachTimeout) {
 */
 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`);
-	}
+	if (opts?.printSummary) process.stdout.write(`\n${renderSummary(report)}\n`);
 	return report;
 }
 /**