stim 1.12.0 → 1.13.0

package/dist/web-run.mjs

@@ -0,0 +1,481 @@
+import { A as ownership_claim_exports, O as process_identity_exports } from "./config-0jCcMM0E.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { l as signalProcessTree } from "./metro-BPeY1YMh.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-DJHoca49.mjs";
+import { r as recordCreatedDevice } from "./created-devices-Cd558h31.mjs";
+import { c as webDir, d as webProfileDir, g as removeSingletonFiles, h as liveProfileHolder, i as clearWebRecord, m as chromeProcessState, n as browserLogFile, o as updateWebRecord, p as writeWebRecord, s as webClaimRoot, u as webLogFile } from "./state-l1pYwOre.mjs";
+import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
+import { n as PHONE_SCREEN, r as chromeArgs } from "./chrome-B5hWgQJS.mjs";
+import { existsSync, mkdirSync, openSync, realpathSync } from "node:fs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { WEB_VIEWPORTS } from "@stim-cli/core/state";
+import { isAbsolute, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/web/events.ts
+const MAX_FRAMES = 20;
+const CONSOLE_LEVELS = {
+	debug: "debug",
+	log: "info",
+	info: "info",
+	dir: "info",
+	table: "info",
+	trace: "info",
+	warning: "warn",
+	error: "error",
+	assert: "error"
+};
+const LOG_ENTRY_LEVELS = {
+	verbose: "debug",
+	info: "info",
+	warning: "warn",
+	error: "error"
+};
+function describeArg(arg) {
+	if (arg.type === "string") return String(arg.value);
+	if (arg.unserializableValue !== void 0) return arg.unserializableValue;
+	if (arg.type === "undefined") return "undefined";
+	if (arg.value !== void 0) return typeof arg.value === "object" ? JSON.stringify(arg.value) : String(arg.value);
+	if (arg.type === "object" && arg.subtype !== "error" && arg.preview?.properties) return describePreview(arg.preview, arg.subtype ?? arg.preview.subtype);
+	return arg.description ?? arg.type ?? "";
+}
+function describePreview(preview, subtype) {
+	const array = subtype === "array";
+	const entries = (preview.properties ?? []).map((property) => {
+		const value = property.type === "string" ? JSON.stringify(property.value ?? "") : property.value ?? "";
+		return array ? value : `${property.name}: ${value}`;
+	});
+	if (preview.overflow) entries.push("...");
+	return array ? `[${entries.join(", ")}]` : `{${entries.join(", ")}}`;
+}
+function frames(stackTrace) {
+	const callFrames = stackTrace?.callFrames;
+	if (!Array.isArray(callFrames)) return [];
+	return callFrames.slice(0, MAX_FRAMES).map((frame) => ({
+		file: frame.url || null,
+		line: typeof frame.lineNumber === "number" ? frame.lineNumber + 1 : null,
+		column: typeof frame.columnNumber === "number" ? frame.columnNumber + 1 : null,
+		fn: frame.functionName || null
+	}));
+}
+function withStack(record, stack) {
+	return stack.length ? {
+		...record,
+		stack
+	} : record;
+}
+/** `Runtime.consoleAPICalled`: a console call in the page, as a `client` record. */
+function consoleRecord(params) {
+	const type = String(params.type ?? "log");
+	const args = Array.isArray(params.args) ? params.args : [];
+	return withStack({
+		src: "client",
+		platform: "web",
+		level: CONSOLE_LEVELS[type] ?? "info",
+		msg: args.map(describeArg).join(" ")
+	}, type === "error" || type === "assert" || type === "trace" ? frames(params.stackTrace) : []);
+}
+/** `Runtime.exceptionThrown`: an uncaught error or rejected promise in the page, as a `client` error. */
+function exceptionRecord(params) {
+	const details = params.exceptionDetails ?? {};
+	const description = (details.exception?.description ?? describeArg(details.exception ?? {})).split("\n")[0];
+	const prefix = details.text ?? "Uncaught";
+	const text = description ? `${prefix} ${description}` : prefix;
+	const stack = frames(details.stackTrace);
+	return withStack({
+		src: "client",
+		platform: "web",
+		level: "error",
+		event: "web_exception",
+		msg: text
+	}, stack.length ? stack : details.url ? [{
+		file: details.url,
+		line: typeof details.lineNumber === "number" ? details.lineNumber + 1 : null,
+		column: typeof details.columnNumber === "number" ? details.columnNumber + 1 : null,
+		fn: null
+	}] : []);
+}
+/**
+* `Log.entryAdded`: a message the browser itself logged, such as a CSP or mixed-content violation. Null for its
+* `network` entries, which repeat the failed requests the Network domain already reports.
+*/
+function logEntryRecord(params) {
+	const entry = params.entry ?? {};
+	if (entry.source === "network") return null;
+	const where = entry.url ? ` (${entry.url})` : "";
+	return {
+		src: "device",
+		platform: "web",
+		level: LOG_ENTRY_LEVELS[entry.level ?? ""] ?? "info",
+		event: "web_browser_log",
+		msg: `${entry.source ? `${entry.source}: ` : ""}${entry.text ?? ""}${where}`
+	};
+}
+/** A request the page made that failed to load or answered with an HTTP error. */
+function networkFailureRecord({ url, method, errorText, status, canceled, document }) {
+	const failure = status === void 0 ? errorText ?? "failed" : `HTTP ${status}`;
+	return {
+		src: "device",
+		platform: "web",
+		level: canceled ? "debug" : document || status === void 0 || status >= 500 ? "error" : "warn",
+		event: canceled ? "web_request_canceled" : document ? "web_document_failed" : "web_request_failed",
+		...status === void 0 ? {} : { status },
+		msg: `${method} ${url} ${canceled ? "canceled" : `failed: ${failure}`}`
+	};
+}
+//#endregion
+//#region src/web/run.ts
+const USAGE = "Usage: web-run --root <path> --chrome <path> --url <url> --port <n> [--launch-id <id>] [--headed] [--viewport desktop|phone] [--ignore-certificate-errors]";
+function parseArgs(argv) {
+	const values = {};
+	let headless = true;
+	let ignoreCertificateErrors = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--headed") headless = false;
+		else if (arg === "--ignore-certificate-errors") ignoreCertificateErrors = true;
+		else if ([
+			"--root",
+			"--chrome",
+			"--url",
+			"--port",
+			"--viewport",
+			"--launch-id"
+		].includes(arg)) {
+			const value = argv[++i];
+			if (value === void 0) return { error: `${arg} needs a value. ${USAGE}` };
+			values[arg.slice(2)] = value;
+		} else return { error: `Unknown browser supervisor argument "${arg}". ${USAGE}` };
+	}
+	const { root, chrome, url } = values;
+	if (!root || !isAbsolute(root)) return { error: `--root must be an absolute path. ${USAGE}` };
+	if (!chrome || !isAbsolute(chrome)) return { error: `--chrome must be an absolute path. ${USAGE}` };
+	if (!url || !/^https?:\/\//.test(url)) return { error: `--url must be an http or https URL. ${USAGE}` };
+	const port = Number(values.port);
+	if (!Number.isInteger(port) || port <= 0 || port > 65535) return { error: `--port must be a TCP port. ${USAGE}` };
+	const viewport = values.viewport ?? "desktop";
+	if (!WEB_VIEWPORTS.includes(viewport)) return { error: `--viewport must be desktop or phone. ${USAGE}` };
+	return {
+		root: resolve(root),
+		launchId: values["launch-id"] ?? null,
+		chrome,
+		url,
+		port,
+		headless,
+		viewport,
+		ignoreCertificateErrors
+	};
+}
+const DEVTOOLS_WAIT_MS = 2e4;
+const CHROME_EXIT_WAIT_MS = 5e3;
+const POLL_MS = 50;
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isWebBundle(url) {
+	return /\.bundle(?:\?|$)/.test(url) && /[?&]platform=web(?:&|$)/.test(url);
+}
+async function runWebSupervisor(options, { onExit = (code) => process.exit(code), stderr = (line) => console.error(line) } = {}) {
+	const root = realpathSync(options.root);
+	mkdirSync(webDir(root), { recursive: true });
+	const writer = createNdjsonWriter(webLogFile(root), { maxBytes: LOG_ROTATE_BYTES });
+	const log = (level, event, msg, extra = {}) => writer.write({
+		src: "device",
+		platform: "web",
+		level,
+		event,
+		msg,
+		...extra
+	});
+	const processToken = (0, process_identity_exports.captureProcessToken)(process.pid);
+	if (!processToken) {
+		stderr("Stim browser supervisor: could not capture process identity; refusing to start an unmanaged browser.");
+		writer.close();
+		onExit(1);
+		return;
+	}
+	const owner = {
+		pid: process.pid,
+		processToken
+	};
+	let claim;
+	try {
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: webClaimRoot(root),
+			mode: "exclusive",
+			label: "browser supervisor",
+			details: { purpose: "browser supervisor" }
+		});
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		claim = attempt.acquired;
+		if (!claim) throw new Error(`another browser supervisor holds ${attempt.held?.path ?? webClaimRoot(root)}`);
+	} catch (error) {
+		stderr(`Stim browser supervisor: ${describe(error)}`);
+		writer.close();
+		onExit(1);
+		return;
+	}
+	const profile = webProfileDir(root);
+	let chrome = null;
+	let chromeRecord = null;
+	let cdp = null;
+	let finished = false;
+	let stopping = false;
+	const chromeGone = () => !chromeRecord || chromeProcessState(chromeRecord) === "gone";
+	const finish = (code, level, event, msg) => {
+		if (finished) return;
+		finished = true;
+		cdp?.close();
+		const gone = chromeGone();
+		if (gone) {
+			try {
+				removeSingletonFiles(profile);
+			} catch {}
+			if (claim) (0, ownership_claim_exports.clearClaimChild)(claim);
+		}
+		if (!gone) {
+			log("error", event, `${msg}; Chrome pid ${chromeRecord?.pid} is still running, so its record and claim are kept for stim stop`);
+			writer.close();
+			onExit(1);
+			return;
+		}
+		log(level, event, msg);
+		try {
+			clearWebRecord(root, owner);
+		} catch {}
+		(0, ownership_claim_exports.releaseClaim)(claim);
+		writer.close();
+		onExit(code);
+	};
+	const stopChrome = async () => {
+		stopping = true;
+		try {
+			await Promise.race([cdp?.send("Browser.close"), sleep(3e3)]);
+		} catch {}
+		const deadline = Date.now() + CHROME_EXIT_WAIT_MS;
+		while (!chromeGone() && Date.now() < deadline) await sleep(POLL_MS);
+		const state = chromeRecord ? chromeProcessState(chromeRecord) : "gone";
+		if (chromeRecord && (state === "running" || state === "lingering")) {
+			try {
+				signalProcessTree(chromeRecord.pid, "SIGKILL", { group: true });
+			} catch {}
+			const killDeadline = Date.now() + 2e3;
+			while (!chromeGone() && Date.now() < killDeadline) await sleep(POLL_MS);
+		}
+	};
+	for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+		stopChrome().then(() => finish(0, "info", "web_browser_stopped", `browser supervisor received ${signal}; closed Chrome`));
+	});
+	try {
+		mkdirSync(profile, { recursive: true });
+		recordCreatedDevice("web", profile);
+		const holder = liveProfileHolder(profile);
+		if (holder !== null) throw new Error(`Chrome pid ${holder} still holds the profile ${profile}`);
+		removeSingletonFiles(profile);
+		const launch = {
+			chrome: options.chrome,
+			headless: options.headless,
+			viewport: options.viewport,
+			ignoreCertificateErrors: options.ignoreCertificateErrors
+		};
+		writeWebRecord(root, {
+			pid: process.pid,
+			processToken,
+			...launch,
+			cdpPort: options.port,
+			profile,
+			url: options.url,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...options.launchId ? { launchId: options.launchId } : {}
+		});
+		const fd = openSync(browserLogFile(root), "a");
+		(0, ownership_claim_exports.markClaimChildPending)(claim);
+		chrome = getExecutor().spawn(options.chrome, chromeArgs({
+			profile,
+			port: options.port,
+			...launch
+		}), {
+			detached: true,
+			stdio: [
+				"ignore",
+				fd,
+				fd
+			]
+		});
+		const pid = chrome.pid;
+		const captured = pid === void 0 ? null : (0, process_identity_exports.captureProcessIdentity)(pid);
+		if (!pid || !captured?.ok) {
+			chrome.kill("SIGKILL");
+			throw new Error(`could not identify the Chrome process${captured && !captured.ok ? `: ${captured.reason}` : ""}`);
+		}
+		chromeRecord = {
+			pid,
+			processToken: captured.token
+		};
+		(0, ownership_claim_exports.setClaimChild)(claim, chromeRecord);
+		updateWebRecord(root, owner, { chromeProcess: chromeRecord });
+		chrome.on("exit", (code, signal) => {
+			if (stopping) return;
+			(async () => {
+				const deadline = Date.now() + 2e3;
+				while (!chromeGone() && Date.now() < deadline) await sleep(POLL_MS);
+				finish(1, "error", "web_browser_exited", `Chrome exited (${signal ? `signal ${signal}` : `exit code ${code}`}); see ${browserLogFile(root)}`);
+			})();
+		});
+		let connection = null;
+		let lastError = null;
+		const deadline = Date.now() + DEVTOOLS_WAIT_MS;
+		const isFinished = () => finished;
+		while (!connection && Date.now() < deadline && !isFinished()) try {
+			connection = await connectOwnedBrowser(options.port, pid);
+		} catch (error) {
+			lastError = error;
+			await sleep(100);
+		}
+		if (!connection) throw new Error(`Chrome did not open DevTools on port ${options.port} within ${DEVTOOLS_WAIT_MS / 1e3}s: ${describe(lastError)}`);
+		cdp = connection;
+		const version = String((await connection.send("Browser.getVersion")).product ?? "");
+		await connection.send("Target.setDiscoverTargets", { discover: true });
+		const { targetInfos } = await connection.send("Target.getTargets");
+		const page = targetInfos?.find((target) => target.type === "page");
+		if (!page) throw new Error("Chrome opened no page");
+		const targetId = page.targetId;
+		const { sessionId } = await connection.send("Target.attachToTarget", {
+			targetId,
+			flatten: true
+		});
+		const requests = /* @__PURE__ */ new Map();
+		connection.onEvent((event) => {
+			if (event.method === "Target.targetDestroyed" && event.params.targetId === targetId && !stopping) {
+				stopChrome().then(() => finish(0, "info", "web_page_closed", "the owned page was closed; closed Chrome"));
+				return;
+			}
+			if (event.method === "Target.targetCrashed" && event.params.targetId === targetId) {
+				log("error", "web_page_crashed", `the page renderer crashed (${String(event.params.status ?? "unknown")})`);
+				return;
+			}
+			if (event.sessionId !== sessionId) return;
+			const params = event.params;
+			switch (event.method) {
+				case "Runtime.consoleAPICalled":
+					writer.write(consoleRecord(params));
+					return;
+				case "Runtime.exceptionThrown":
+					writer.write(exceptionRecord(params));
+					return;
+				case "Log.entryAdded": {
+					const record = logEntryRecord(params);
+					if (record) writer.write(record);
+					return;
+				}
+				case "Page.loadEventFired":
+					log("info", "web_page_loaded", "the page fired its load event");
+					return;
+				case "Network.requestWillBeSent": {
+					const request = params.request;
+					const document = params.type === "Document" && params.frameId === targetId;
+					requests.set(String(params.requestId), {
+						url: request.url,
+						method: request.method,
+						document
+					});
+					if (document) log("info", "web_navigation", `navigating to ${request.url}`, {
+						url: request.url,
+						marker: true
+					});
+					return;
+				}
+				case "Network.responseReceived": {
+					const facts = requests.get(String(params.requestId));
+					const response = params.response;
+					if (!facts) return;
+					if (facts.document) log("info", "web_document_response", `${response.status} ${response.url}`, { status: response.status });
+					if (isWebBundle(response.url)) log(response.status < 400 ? "info" : "error", "web_bundle_response", `${response.status} ${response.url}`, { status: response.status });
+					if (response.status >= 400) writer.write(networkFailureRecord({
+						...facts,
+						url: response.url,
+						status: response.status
+					}));
+					return;
+				}
+				case "Network.loadingFinished":
+					requests.delete(String(params.requestId));
+					return;
+				case "Network.loadingFailed": {
+					const facts = requests.get(String(params.requestId));
+					requests.delete(String(params.requestId));
+					if (!facts) return;
+					writer.write(networkFailureRecord({
+						...facts,
+						errorText: String(params.errorText ?? "failed"),
+						canceled: params.canceled === true
+					}));
+					return;
+				}
+			}
+		});
+		connection.onClose(() => {
+			if (!stopping && chromeGone()) finish(1, "error", "web_browser_exited", "Chrome closed its DevTools connection");
+		});
+		for (const domain of [
+			"Runtime",
+			"Log",
+			"Network",
+			"Page"
+		]) await connection.send(`${domain}.enable`, {}, sessionId);
+		if (options.viewport === "phone") {
+			await connection.send("Emulation.setDeviceMetricsOverride", {
+				...PHONE_SCREEN,
+				mobile: true
+			}, sessionId);
+			await connection.send("Emulation.setTouchEmulationEnabled", {
+				enabled: true,
+				maxTouchPoints: 5
+			}, sessionId);
+		}
+		updateWebRecord(root, owner, {
+			targetId,
+			version
+		});
+		log("info", "web_browser_started", `browser supervisor pid ${process.pid} runs ${version} (pid ${pid}) on ${profile}`);
+		connection.send("Page.navigate", { url: options.url }, sessionId).catch((error) => {
+			log("debug", "web_navigation_slow", `Page.navigate did not answer: ${describe(error)}; the page may still load`);
+		});
+	} catch (error) {
+		stderr(`Stim browser supervisor: ${describe(error)}`);
+		await stopChrome();
+		finish(1, "error", "web_browser_failed", `could not start the owned Chrome: ${describe(error)}`);
+	}
+}
+async function main(argv = process.argv.slice(2)) {
+	if (relaunchWithLogFile(argv)) return;
+	const parsed = parseArgs(argv);
+	if ("error" in parsed) {
+		console.error(`Stim browser supervisor: ${parsed.error}`);
+		process.exit(2);
+		return;
+	}
+	if (!existsSync(parsed.root)) {
+		console.error(`Stim browser supervisor: --root ${parsed.root} does not exist.`);
+		process.exit(2);
+		return;
+	}
+	process.title = "stim-web";
+	await runWebSupervisor(parsed);
+}
+function invokedDirectly() {
+	const entry = process.argv[1];
+	if (!entry) return false;
+	try {
+		return resolve(entry) === fileURLToPath(import.meta.url);
+	} catch {
+		return false;
+	}
+}
+if (invokedDirectly()) main().catch((error) => {
+	console.error(`Stim browser supervisor: ${describe(error)}`);
+	process.exit(1);
+});
+//#endregion
+export { main, parseArgs, runWebSupervisor };