stim 1.14.0 → 1.15.0

package/dist/web-run.mjs

@@ -1,16 +1,17 @@
-import { A as ownership_claim_exports, O as process_identity_exports } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { l as signalProcessTree } from "./metro-CcEo8Fl8.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-DJHoca49.mjs";
-import { r as recordCreatedDevice } from "./created-devices-CllH_8eb.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-Dk9RVXI7.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
+import { a as probeWebDrivers } from "./activity-B2-kb7k0.mjs";
+import { r as recordCreatedDevice } from "./created-devices-BwVb3liH.mjs";
+import { u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
+import { _ as removeSingletonFiles, c as webClaimRoot, d as webLogFile, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, l as webDir, m as writeWebRecord, n as browserLogFile, s as updateWebRecord } from "./state-DFm77wRn.mjs";
 import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
-import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-BPCiC3ZX.mjs";
+import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-BrcVWQyD.mjs";
 import { existsSync, mkdirSync, openSync, realpathSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
 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;
@@ -124,6 +125,220 @@ function networkFailureRecord({ url, method, errorText, status, canceled, docume
 	};
 }
 //#endregion
+//#region src/web/input.ts
+/** The isolated world the input listener runs in, so the page's own scripts cannot see or replace it. */
+const INPUT_WORLD = "stim";
+const INPUT_BINDING = "__stimInput";
+/**
+* Observes trusted clicks, key presses, text input and wheel scrolls in the page and reports them through the
+* binding, coalesced: one action per click, per typing burst in a field, per repeated key and per scroll burst.
+* Typed text is never reported, only its length. Input up to 3 seconds after a `stim-takeover` event on the window,
+* which Stim's Take over dispatches while it sends input, is dropped; so is input just before one, since the event
+* and the input reach the page by different routes.
+*/
+const INPUT_LISTENER = `(() => {
+  const send = globalThis.${INPUT_BINDING};
+  if (typeof send !== 'function' || window !== window.top) return;
+  const BURST_MS = 1000, FLUSH_MS = 1000, MAX_WAIT_MS = 3000, TAKEOVER_MS = 3000, MAX_ACTIONS = 50;
+  let pending = [], marks = [], dropped = 0, lastKeyAt = -Infinity, timer = 0, firstAt = 0;
+  const clip = (value, max) => {
+    const text = String(value || '').replace(/\\s+/g, ' ').trim();
+    return text.length > max ? text.slice(0, max - 3) + '...' : text;
+  };
+  const ROLES = ['button', 'link', 'tab', 'menuitem', 'checkbox', 'radio', 'switch', 'option', 'textbox', 'combobox', 'searchbox'];
+  const INTERACTIVE = 'a[href],button,input,textarea,select,label,summary,[contenteditable=""],[contenteditable=true],[data-testid],'
+    + ROLES.map((role) => '[role=' + role + ']').join(',');
+  const describe = (node, withText) => {
+    if (!(node instanceof Element)) return null;
+    const el = node.closest(INTERACTIVE) || node;
+    const tag = el.tagName.toLowerCase();
+    let out = tag;
+    if (el.id) out += '#' + clip(el.id, 40);
+    if (tag === 'input') out += '[type=' + (el.getAttribute('type') || 'text') + ']';
+    const role = el.getAttribute('role');
+    if (role) out += '[role=' + clip(role, 20) + ']';
+    const testId = el.getAttribute('data-testid');
+    if (testId) out += '[data-testid=' + clip(testId, 40) + ']';
+    const field = tag === 'input' || tag === 'textarea' || tag === 'select' || el.isContentEditable;
+    const editable = node.isContentEditable || el.querySelector('input,textarea,select,[contenteditable]') !== null;
+    const name = el.getAttribute('aria-label') || (field
+      ? el.getAttribute('placeholder') || el.getAttribute('name')
+      : withText && !editable ? el.textContent : '');
+    const label = clip(name, 40);
+    return label ? out + ' "' + label.replace(/"/g, "'") + '"' : out;
+  };
+  const flush = () => {
+    clearTimeout(timer);
+    timer = 0;
+    const now = performance.now();
+    marks = marks.filter((at) => at > now - TAKEOVER_MS - MAX_WAIT_MS - BURST_MS);
+    const actions = pending
+      .filter((action) => !marks.some((at) => at >= action.start - TAKEOVER_MS && at <= action.end + 500))
+      .map(({ start, end, ...action }) => ({ ...action, at: Math.round(performance.timeOrigin + start) }));
+    const lost = dropped;
+    pending = [];
+    dropped = 0;
+    if (actions.length || lost) send(JSON.stringify({ actions, dropped: lost }));
+  };
+  const add = (action, merge) => {
+    const now = performance.now();
+    const last = pending[pending.length - 1];
+    if (last && last.command === action.command && now - last.end < BURST_MS && merge(last)) {
+      last.end = now;
+    } else if (pending.length >= MAX_ACTIONS) {
+      dropped += 1;
+    } else {
+      if (!pending.length) {
+        firstAt = now;
+        send('started');
+      }
+      pending.push({ ...action, start: now, end: now });
+    }
+    clearTimeout(timer);
+    timer = setTimeout(flush, Math.max(0, Math.min(FLUSH_MS, firstAt + MAX_WAIT_MS - now)));
+  };
+  const typed = (target, characters) =>
+    add({ command: 'type', target, characters }, (last) => last.target === target && (last.characters += characters, true));
+  const origin = (event) => event.composedPath()[0] || event.target;
+  addEventListener('stim-takeover', () => marks.push(performance.now()), true);
+  addEventListener('beforeunload', flush, true);
+  addEventListener('click', (event) => {
+    if (!event.isTrusted) return;
+    add({ command: 'click', target: describe(origin(event), true), x: Math.round(event.clientX), y: Math.round(event.clientY) }, () => false);
+  }, true);
+  addEventListener('keydown', (event) => {
+    if (!event.isTrusted || event.isComposing) return;
+    const key = event.key;
+    if (!key || key === 'Shift' || key === 'Control' || key === 'Alt' || key === 'Meta' || key === 'CapsLock') return;
+    if ([...key].length === 1 || key === 'Enter') lastKeyAt = performance.now();
+    const target = describe(origin(event), false);
+    const modifiers = (event.ctrlKey ? 'Control+' : '') + (event.metaKey ? 'Meta+' : '');
+    if ([...key].length === 1 && !modifiers) {
+      typed(target, 1);
+      return;
+    }
+    const name = modifiers + (event.altKey ? 'Alt+' : '') + (key === ' ' ? 'Space' : key);
+    add({ command: 'press', target, key: name, count: 1 }, (last) => last.key === name && last.target === target && (last.count += 1, true));
+  }, true);
+  addEventListener('input', (event) => {
+    if (!event.isTrusted || typeof event.inputType !== 'string' || !event.inputType.startsWith('insert')) return;
+    if (performance.now() - lastKeyAt < 100) return;
+    typed(describe(origin(event), false), typeof event.data === 'string' && event.data ? event.data.length : 1);
+  }, true);
+  addEventListener('wheel', (event) => {
+    if (!event.isTrusted) return;
+    const scale = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? innerHeight : 1;
+    const deltaX = event.deltaX * scale, deltaY = event.deltaY * scale;
+    add({ command: 'scroll', deltaX, deltaY, x: Math.round(event.clientX), y: Math.round(event.clientY) }, (last) => {
+      last.deltaX += deltaX;
+      last.deltaY += deltaY;
+      return true;
+    });
+  }, { capture: true, passive: true });
+})();`;
+const num = (value) => typeof value === "number" && Number.isFinite(value);
+const text = (value) => typeof value === "string" && value ? value.slice(0, 200) : null;
+function parseAction(value) {
+	if (!value || typeof value !== "object") return null;
+	const entry = value;
+	if (!num(entry.at)) return null;
+	const { at } = entry;
+	switch (entry.command) {
+		case "click": return num(entry.x) && num(entry.y) ? {
+			command: "click",
+			at,
+			target: text(entry.target),
+			x: entry.x,
+			y: entry.y
+		} : null;
+		case "type": return num(entry.characters) ? {
+			command: "type",
+			at,
+			target: text(entry.target),
+			characters: entry.characters
+		} : null;
+		case "press": {
+			const key = text(entry.key);
+			return key && num(entry.count) ? {
+				command: "press",
+				at,
+				target: text(entry.target),
+				key,
+				count: entry.count
+			} : null;
+		}
+		case "scroll": return num(entry.deltaX) && num(entry.deltaY) && num(entry.x) && num(entry.y) ? {
+			command: "scroll",
+			at,
+			deltaX: entry.deltaX,
+			deltaY: entry.deltaY,
+			x: entry.x,
+			y: entry.y
+		} : null;
+		default: return null;
+	}
+}
+/** The batch the input listener sent, keeping only well-formed actions. */
+function parseInputBatch(payload) {
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return {
+			actions: [],
+			dropped: 0
+		};
+	}
+	const batch = parsed ?? {};
+	return {
+		actions: Array.isArray(batch.actions) ? batch.actions.map(parseAction).filter((action) => action !== null) : [],
+		dropped: num(batch.dropped) && batch.dropped > 0 ? batch.dropped : 0
+	};
+}
+function scrollSummary(deltaX, deltaY) {
+	const parts = [Math.round(deltaY) ? `${deltaY > 0 ? "down" : "up"} ${Math.abs(Math.round(deltaY))}px` : "", Math.round(deltaX) ? `${deltaX > 0 ? "right" : "left"} ${Math.abs(Math.round(deltaX))}px` : ""].filter(Boolean);
+	return parts.length ? `Scrolled ${parts.join(" and ")}` : "Scrolled";
+}
+function summary(action) {
+	switch (action.command) {
+		case "click": return `Clicked ${action.target ?? "the page"}`;
+		case "type": return `Typed ${action.characters} character${action.characters === 1 ? "" : "s"} into ${action.target ?? "the page"}`;
+		case "press": return `Pressed ${action.key}${action.count > 1 ? ` x${action.count}` : ""}${action.target ? ` in ${action.target}` : ""}`;
+		case "scroll": return scrollSummary(action.deltaX, action.deltaY);
+	}
+}
+/**
+* The `agent` records for input the DevTools client `driver` sent to the owned page `targetId`, in the shape of
+* agent-device's action records.
+*/
+function webAgentRecords(batch, targetId, driver, now) {
+	const base = {
+		src: "agent",
+		level: "info",
+		event: "agent_action",
+		platform: "web",
+		deviceId: targetId,
+		driver
+	};
+	const records = batch.actions.map((action) => {
+		const { at, command, ...details } = action;
+		return {
+			ts: at,
+			...base,
+			msg: summary(action),
+			command,
+			details
+		};
+	});
+	if (batch.dropped) records.push({
+		ts: now,
+		...base,
+		msg: `${batch.dropped} more input event${batch.dropped === 1 ? " was" : "s were"} not recorded`,
+		command: "input"
+	});
+	return records;
+}
+//#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) {
@@ -167,6 +382,7 @@ function parseArgs(argv) {
 	};
 }
 const DEVTOOLS_WAIT_MS = 2e4;
+const ROUTE_THROTTLE_MS = 250;
 const CHROME_EXIT_WAIT_MS = 5e3;
 const POLL_MS = 50;
 const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
@@ -176,6 +392,19 @@ function describe(error) {
 function isWebBundle(url) {
 	return /\.bundle(?:\?|$)/.test(url) && /[?&]platform=web(?:&|$)/.test(url);
 }
+function createDriverProbe(port, ownPids) {
+	let running = null;
+	return () => {
+		running ??= probeWebDrivers({
+			port,
+			ownPids
+		}).catch(() => null).then((drivers) => {
+			running = null;
+			return drivers?.[0] ?? null;
+		});
+		return running;
+	};
+}
 async function runWebSupervisor(options, { onExit = (code) => process.exit(code), stderr = (line) => console.error(line) } = {}) {
 	const root = realpathSync(options.root);
 	mkdirSync(webDir(root), { recursive: true });
@@ -346,6 +575,22 @@ async function runWebSupervisor(options, { onExit = (code) => process.exit(code)
 			flatten: true
 		});
 		const requests = /* @__PURE__ */ new Map();
+		const driver = createDriverProbe(options.port, [process.pid, pid]);
+		let batchDriver = null;
+		let reloading = false;
+		let route = {
+			written: null,
+			latest: null,
+			at: 0,
+			timer: null
+		};
+		const writeRoute = () => {
+			route.timer = null;
+			if (route.latest === null || route.latest === route.written) return;
+			route.written = route.latest;
+			route.at = Date.now();
+			log("info", "web_route", `route changed to ${route.latest}`, { url: route.latest });
+		};
 		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"));
@@ -369,6 +614,35 @@ async function runWebSupervisor(options, { onExit = (code) => process.exit(code)
 					if (record) writer.write(record);
 					return;
 				}
+				case "Runtime.bindingCalled": {
+					if (params.name !== "__stimInput") return;
+					if (params.payload === "started") {
+						batchDriver = driver();
+						return;
+					}
+					const batch = parseInputBatch(String(params.payload ?? ""));
+					const attributed = batchDriver ?? driver();
+					batchDriver = null;
+					if (!batch.actions.length && !batch.dropped) return;
+					(async () => {
+						const attached = await attributed;
+						if (!attached) return;
+						for (const record of webAgentRecords(batch, targetId, attached.tool, Date.now())) writer.write(record);
+					})();
+					return;
+				}
+				case "Page.frameStartedNavigating":
+					if (params.frameId === targetId) reloading = String(params.navigationType).startsWith("reload");
+					return;
+				case "Page.navigatedWithinDocument": {
+					if (params.frameId !== targetId || typeof params.url !== "string") return;
+					route.latest = params.url;
+					if (route.timer) return;
+					const wait = route.at + ROUTE_THROTTLE_MS - Date.now();
+					if (wait <= 0) writeRoute();
+					else route.timer = setTimeout(writeRoute, wait);
+					return;
+				}
 				case "Page.loadEventFired":
 					log("info", "web_page_loaded", "the page fired its load event");
 					return;
@@ -380,10 +654,21 @@ async function runWebSupervisor(options, { onExit = (code) => process.exit(code)
 						method: request.method,
 						document
 					});
-					if (document) log("info", "web_navigation", `navigating to ${request.url}`, {
-						url: request.url,
-						marker: true
-					});
+					if (document) {
+						if (route.timer) clearTimeout(route.timer);
+						route = {
+							written: null,
+							latest: null,
+							at: 0,
+							timer: null
+						};
+						log("info", "web_navigation", `${reloading ? "reloading" : "navigating to"} ${request.url}`, {
+							url: request.url,
+							marker: true,
+							...reloading ? { reload: true } : {}
+						});
+						reloading = false;
+					}
 					return;
 				}
 				case "Network.responseReceived": {
@@ -424,6 +709,18 @@ async function runWebSupervisor(options, { onExit = (code) => process.exit(code)
 			"Network",
 			"Page"
 		]) await connection.send(`${domain}.enable`, {}, sessionId);
+		try {
+			await connection.send("Runtime.addBinding", {
+				name: INPUT_BINDING,
+				executionContextName: INPUT_WORLD
+			}, sessionId);
+			await connection.send("Page.addScriptToEvaluateOnNewDocument", {
+				source: INPUT_LISTENER,
+				worldName: INPUT_WORLD
+			}, sessionId);
+		} catch (error) {
+			log("warn", "web_input_unobserved", `agent input on the page is not recorded: ${describe(error)}`);
+		}
 		if (options.viewport === "phone") {
 			await connection.send("Emulation.setDeviceMetricsOverride", {
 				...PHONE_SCREEN,

package/dist/workspace-process-lock-BL7Q0HCO.mjs

@@ -0,0 +1,57 @@
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-D0XfSe8u.mjs";
+import { join } from "node:path";
+//#region src/engine/workspace-process-lock.ts
+const DEFAULT_WAIT_MS = 6e4;
+const POLL_MS = 25;
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function workspaceProcessLockError(err) {
+	const code = err?.code;
+	if (code === "STIM_LOCK_REFUSED") return "refused";
+	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
+	return null;
+}
+function workspaceProcessLockPath(root, name, external) {
+	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
+}
+async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
+	const deadline = now() + waitMs;
+	for (;;) {
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: path,
+			mode: "exclusive",
+			label: `${name} lock`,
+			details: ownerPurpose ? {
+				...details,
+				purpose: ownerPurpose
+			} : details
+		});
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		if (attempt.acquired) {
+			if (declareSpawns) declareSpawnsOn(attempt.acquired);
+			try {
+				return await fn(attempt.acquired);
+			} finally {
+				stopDeclaringSpawnsOn(attempt.acquired);
+				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+			}
+		}
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		const purpose = holder?.details.purpose;
+		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
+			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
+			error.code = "STIM_LOCK_REFUSED";
+			throw error;
+		}
+		if (holder && onHeld) await onHeld(holder);
+		if (now() >= deadline) {
+			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
+			error.code = "STIM_LOCK_TIMEOUT";
+			throw error;
+		}
+		await sleep(POLL_MS);
+	}
+}
+//#endregion
+export { workspaceProcessLockError as n, workspaceProcessLockPath as r, withWorkspaceProcessLock as t };