import assert from "node:assert/strict"; import { randomUUID } from "node:crypto"; import { once } from "node:events"; import { mkdtemp, readFile, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { spawnOwnedProviderProcess } from "../../dist/process/ProviderProcess.js"; import { createSystemProcessOwnershipHost } from "../../dist/process/ProcessOwnershipObservation.js"; import { liveProcesses } from "../../dist/process/ProcessOwnershipProcessTree.js"; import { CdpConnection } from "../../dist/browser/CdpConnection.js"; import { BROWSER_DEVTOOLS_STARTUP_TIMEOUT_MS, waitForBrowserDevtoolsPort, } from "../../dist/browser/BrowserProcessStartup.js"; import { discoverCdpEndpoint } from "../../dist/browser/CdpEndpoint.js"; import { BrowserObservationError } from "../../dist/domain/browserObservationError.js"; /** Admit the owned fixture only after CDP serves its requested page. */ export async function startRuntimeFixtureBrowser(executable, origin) { const profile = await mkdtemp(join(tmpdir(), "rea-real-web-runtime-")); const deadline = performance.now() + BROWSER_DEVTOOLS_STARTUP_TIMEOUT_MS; let owned; try { owned = await spawnOwnedProviderProcess({ command: executable, arguments: [ "--headless=new", "--password-store=basic", ...(process.env.REA_BROWSER_NO_SANDBOX === "true" ? ["--no-sandbox"] : []), "--remote-debugging-address=127.0.0.1", "--remote-debugging-port=0", `--user-data-dir=${profile}`, "--no-first-run", "--no-default-browser-check", "--disable-background-networking", "--disable-component-update", "--disable-dev-shm-usage", "--disable-sync", origin, ], runId: randomUUID(), // Installed Chrome launch scripts exec another binary; do not require an argv prefix. expectedCommand: null, }); owned.process.stdout?.resume(); let stderr = ""; owned.process.stderr?.on("data", (chunk) => { if (stderr.length < 65536) stderr += chunk; }); const port = await waitForBrowserDevtoolsPort({ child: owned.process, executable, activePortPath: join(profile, "DevToolsActivePort"), stderr: () => stderr, // Match the broader real-browser verifier's allowance for cold Chrome // startup on shared runners; early process failures still reject at once. timeoutMs: Math.max(1, deadline - performance.now()), }); // Port publication can precede a responsive discovery service and renderer. // Both phases share the owned fixture's startup budget; public CDP calls // retain their normal per-response deadlines and failure semantics. await waitForRuntimeFixturePage({ child: owned.process, port, origin, deadline, }); return { port, close: async () => { await stopOwnedBrowser(owned, profile); await rm(profile, { recursive: true, force: true, maxRetries: 5, retryDelay: 100, }); }, }; } catch (cause) { await closeRuntimeFixtureResources( [ async () => { // Keep the profile when stopping its browser cannot be confirmed. if (owned !== undefined) await stopOwnedBrowser(owned, profile); await rm(profile, { recursive: true, force: true, maxRetries: 5, retryDelay: 100, }); }, ], cause, ); throw cause; } } async function waitForRuntimeFixturePage({ child, port, origin, deadline }) { const controller = new AbortController(); let lastFailure; const onExit = () => controller.abort( new Error( "Owned runtime fixture exited before CDP discovery became ready", { cause: lastFailure }, ), ); const onError = (cause) => controller.abort(cause); const timer = setTimeout( () => controller.abort( new Error( "Owned runtime fixture page was not discoverable within its startup budget", { cause: lastFailure }, ), ), Math.max(1, deadline - performance.now()), ); child.once("exit", onExit); child.once("error", onError); try { for (;;) { if (child.exitCode !== null || child.signalCode !== null) onExit(); controller.signal.throwIfAborted(); try { const discovery = await discoverCdpEndpoint( `http://127.0.0.1:${port}`, "list_browser_targets", controller.signal, ); if ( discovery.targets.some( (target) => target.type === "page" && (target.url === origin || target.url.startsWith(`${origin}/`)), ) ) return; } catch (cause) { controller.signal.throwIfAborted(); // Only transient startup failures are retryable. Invalid protocol // responses and payload-limit failures must remain visible immediately. if ( !(cause instanceof BrowserObservationError) || !["timeout", "endpoint_unreachable"].includes(cause.reason) ) throw cause; lastFailure = cause; } await new Promise((resolve) => setTimeout(resolve, 25)); } } finally { clearTimeout(timer); child.removeListener("exit", onExit); child.removeListener("error", onError); } } async function stopOwnedBrowser(owned, profile) { const child = owned.process; const exited = child.exitCode === null && child.signalCode === null ? once(child, "exit") : Promise.resolve(); void exited.catch(() => undefined); let connection; let timer; const escalation = setTimeout(() => { if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL"); }, 2_000); try { if (child.exitCode === null && child.signalCode === null) { try { const [port, browserPath] = ( await readFile(join(profile, "DevToolsActivePort"), "utf8") ) .trim() .split("\n"); assert.match(port, /^\d+$/); assert.match(browserPath, /^\/devtools\/browser\/[^\s]+$/); const signal = AbortSignal.timeout(2_000); connection = await CdpConnection.connect( `ws://127.0.0.1:${port}${browserPath}`, "inspect_web_page", signal, ); // This browser belongs to the verifier; public REA operations never close it. await connection.send("Browser.close", {}, undefined, signal); } catch { if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM"); } } if (owned.cleanup !== undefined) { const result = await owned.cleanup(); assert.equal(result.cleaned, true, JSON.stringify(result)); } await Promise.race([ exited, new Promise((_, reject) => { timer = setTimeout( () => reject( new Error("Owned fixture browser did not exit after shutdown"), ), 5_000, ); }), ]); } finally { clearTimeout(escalation); clearTimeout(timer); await connection?.close(); } if (process.platform === "win32") return; const host = createSystemProcessOwnershipHost(); const deadline = Date.now() + 5_000; while (true) { const members = liveProcesses(await host.listProcesses()).filter( (member) => member.processGroupId === owned.ownership.processGroupId, ); if (members.length === 0) return; if (Date.now() >= deadline) throw new Error( `Owned fixture group remains: ${JSON.stringify(members.map(({ pid }) => pid))}`, ); await new Promise((resolve) => setTimeout(resolve, 25)); } } /** Attempt every owned cleanup and retain the original verification failure if cleanup also fails. */ export async function closeRuntimeFixtureResources(tasks, primaryError) { const failures = []; for (const task of tasks) { try { await task(); } catch (cause) { failures.push(cause); } } if (failures.length > 0) throw new AggregateError( primaryError === undefined ? failures : [primaryError, ...failures], "Runtime fixture cleanup failed", ); }