stim 1.20.2 → 1.22.0

package/dist/logs-BfwwadsZ.mjs

@@ -0,0 +1,479 @@
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { G as projectDeviceSlots, _ as loadConfig$1 } from "./config-DlrsduwG.mjs";
+import { n as pullHostedNativeLogs, t as pullHostedMacosLogs } from "./hosted-logs-FIRx9X2f.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { f as readAgentDeviceRecordsAsync, n as agentDeviceLiveness, o as envDir } from "./activity-CMLmzp7o.mjs";
+import { l as connectHost } from "./hosted-client-DZAPrcro.mjs";
+import { n as readHostedIos, t as readHostedAndroid } from "./ios-state-Dtw5K2aI.mjs";
+import "./hosted-macos-_awYSpfv.mjs";
+import { i as captureWorkspaceCrashes } from "./error-diagnostics-DBWO2rxE.mjs";
+import { readdirSync, statSync, watch } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { ambientWrite, configDir } from "@stim-cli/core";
+import { LEVELS, SOURCES, agentDeviceStateDirsAsync, buildCriteria, compileGrep, createAsyncAgentActionReader, followLogs, logFiles, openLogDir, parseSince, readMacosRecord, recordMatches, workspaceStateFile } from "@stim-cli/core/state";
+import { setImmediate } from "node:timers/promises";
+import { realpath } from "node:fs/promises";
+//#region src/devices/agent-actions.ts
+function workspaceAgentTargets(project, macos) {
+	const targets = [];
+	if (macos?.app && macos.bundleId) targets.push({
+		platform: "macos",
+		id: macos.launchId,
+		slot: "default",
+		bundleId: macos.bundleId,
+		launchedAt: macos.app.startedAtMicros / 1e3
+	});
+	let slots;
+	try {
+		slots = projectDeviceSlots(project);
+	} catch {
+		return [];
+	}
+	for (const { slot, platforms } of slots) {
+		const { ios, android } = platforms;
+		if (ios?.owned && typeof ios.deviceUdid === "string") targets.push({
+			platform: "ios",
+			id: ios.deviceUdid,
+			slot
+		});
+		if (android?.owned && typeof android.consolePort === "number" && typeof android.avdName === "string") targets.push({
+			platform: "android",
+			id: `emulator-${android.consolePort}`,
+			slot,
+			name: android.avdName
+		});
+	}
+	return targets;
+}
+function createAsyncAgentActionReader$1({ targets, sinceTs, home = homedir(), env, now, startOf = process_identity_exports.inspectProcessStart }, signal) {
+	let sessionsDirs = [];
+	let claimed = /* @__PURE__ */ new Map();
+	let canonical = /* @__PURE__ */ new Map();
+	const read = createAsyncAgentActionReader({
+		sessionsDirs: () => sessionsDirs,
+		targets,
+		sinceTs,
+		now,
+		claimedDevice: (session, sessionsDir) => claimed.get(`${canonical.get(dirname(sessionsDir))}\0${session}`) ?? claimed.get(`\0${session}`) ?? null
+	}, signal);
+	return async (selection) => {
+		signal?.throwIfAborted();
+		const roots = await agentDeviceStateDirsAsync(home, env);
+		canonical = /* @__PURE__ */ new Map();
+		const canonicalize = async (path) => {
+			if (canonical.has(path)) return canonical.get(path);
+			const value = await realpath(path).catch(() => resolve(path));
+			canonical.set(path, value);
+			return value;
+		};
+		for (const root of roots) await canonicalize(root);
+		sessionsDirs = roots.map((root) => join(root, "sessions"));
+		claimed = /* @__PURE__ */ new Map();
+		const byId = new Map((typeof targets === "function" ? targets() : targets).map((target) => [target.id, target]));
+		if ([...byId.values()].some((target) => target.platform !== "macos")) for (const record of await readAgentDeviceRecordsAsync(home, env)) {
+			signal?.throwIfAborted();
+			if (record.kind !== "claim" || !record.session || !record.deviceId) continue;
+			const target = byId.get(record.deviceId);
+			if (!target || target.platform === "macos" || target.name !== void 0 && target.name !== record.deviceName) continue;
+			if (agentDeviceLiveness(record, startOf) === "live") claimed.set(`${record.stateDir ? await canonicalize(record.stateDir) : ""}\0${record.session}`, record.deviceId);
+			await setImmediate();
+		}
+		signal?.throwIfAborted();
+		return read(selection);
+	};
+}
+//#endregion
+//#region src/devices/agent-actions-follow.ts
+function location(root, recursive) {
+	let directory = root;
+	while (true) {
+		try {
+			const info = statSync(directory);
+			if (info.isDirectory()) return {
+				directory,
+				identity: `${info.dev}:${info.ino}`,
+				recursive: recursive && directory === root
+			};
+		} catch {}
+		const parent = dirname(directory);
+		if (parent === directory) throw new Error(`Cannot watch the agent state directory ${root}.`);
+		directory = parent;
+	}
+}
+function relevant(root, directory, name) {
+	if (name === null || directory === root) return true;
+	return name.replaceAll("\\", "/").split("/")[0] === relative(directory, root).split(sep)[0];
+}
+function followAgentActions(context, read, onRecord) {
+	const home = context.env.HOME ?? homedir();
+	const override = context.env.AGENT_DEVICE_STATE_DIR?.trim();
+	const workspaces = join(context.home, "workspaces");
+	const baseRoots = /* @__PURE__ */ new Map([
+		[override ? resolve(override) : join(home, ".agent-device"), true],
+		[envDir("AGENT_DEVICE_CLAIMS_DIR", context.env) ?? join(home, ".agent-device", "device-claims"), true],
+		[workspaces, false]
+	]);
+	let rootCount = baseRoots.size;
+	const bindings = /* @__PURE__ */ new Map();
+	let stopped = false;
+	let reading = false;
+	let pending = false;
+	let repair;
+	let scheduled;
+	const refresh = async () => {
+		if (stopped) return;
+		if (reading) {
+			pending = true;
+			return;
+		}
+		reading = true;
+		try {
+			for (const record of await read()) {
+				if (stopped) break;
+				onRecord(record);
+			}
+		} catch {} finally {
+			reading = false;
+			if (pending) {
+				pending = false;
+				refresh();
+			}
+		}
+	};
+	const scheduleRefresh = () => {
+		if (stopped || scheduled !== void 0) return;
+		scheduled = setTimeout(() => {
+			scheduled = void 0;
+			refresh();
+		}, 500);
+	};
+	const reconcile = () => {
+		const roots = new Map(baseRoots);
+		try {
+			for (const entry of readdirSync(workspaces, { withFileTypes: true })) if (entry.isDirectory() || entry.isSymbolicLink()) roots.set(join(workspaces, entry.name, "agent-device"), true);
+		} catch {}
+		rootCount = roots.size;
+		for (const [root, binding] of bindings) {
+			if (roots.has(root)) continue;
+			bindings.delete(root);
+			binding.watcher.close();
+		}
+		for (const [root, recursive] of roots) {
+			let next;
+			try {
+				next = location(root, recursive);
+			} catch {
+				continue;
+			}
+			const current = bindings.get(root);
+			if (current?.directory === next.directory && current.identity === next.identity && current.recursive === next.recursive) continue;
+			bindings.delete(root);
+			current?.watcher.close();
+			try {
+				const watcher = watch(next.directory, { recursive: next.recursive }, (event, name) => {
+					if (stopped || !relevant(root, next.directory, name)) return;
+					if (event === "rename" || next.directory !== root) reconcile();
+					scheduleRefresh();
+				});
+				const binding = {
+					...next,
+					watcher
+				};
+				bindings.set(root, binding);
+				const lost = () => {
+					if (bindings.get(root) !== binding) return;
+					bindings.delete(root);
+					watcher.close();
+					armRepair(500);
+				};
+				watcher.once("error", lost);
+				watcher.once("close", lost);
+			} catch {}
+		}
+	};
+	function armRepair(delay) {
+		clearTimeout(repair);
+		if (stopped) return;
+		repair = setTimeout(() => {
+			reconcile();
+			refresh();
+			armRepair(bindings.size < rootCount ? 500 : 1e4);
+		}, delay);
+	}
+	const stop = () => {
+		if (stopped) return;
+		stopped = true;
+		clearTimeout(repair);
+		clearTimeout(scheduled);
+		for (const { watcher } of bindings.values()) watcher.close();
+		bindings.clear();
+		context.signal.removeEventListener("abort", stop);
+	};
+	context.signal.addEventListener("abort", stop, { once: true });
+	if (context.signal.aborted) stop();
+	else {
+		reconcile();
+		refresh();
+		armRepair(500);
+	}
+	return stop;
+}
+//#endregion
+//#region src/device-host/hosted-logs-sync.ts
+function warn(context, machine, error) {
+	const text = `${warning(machine, error)}\n`;
+	if (context) context.output("stderr", text);
+	else ambientWrite("stderr", text);
+}
+function warning(machine, error) {
+	const message = error.message.replace(/\.$/, "");
+	const hint = message.includes("refused device-host.logs.query") ? ` If ${machine} runs an older stim-server, update it.` : "";
+	return phaseLine("device", `Could not read the app's logs from ${machine}: ${message}. Showing the logs already copied here.${hint}`);
+}
+async function syncHostedMacosLogs(root, placement, slot, warnings, platform = "ios", context) {
+	let host;
+	const cancel = () => host?.connection.close();
+	context?.signal.addEventListener("abort", cancel, { once: true });
+	try {
+		host = await connectHost(placement.machine, void 0, false, context?.signal);
+		if (slot !== void 0) await pullHostedNativeLogs(root, slot, placement, host, false, platform, context?.signal);
+		else await pullHostedMacosLogs(root, placement, host, void 0, void 0, false, context?.signal);
+		return true;
+	} catch (error) {
+		context?.signal.throwIfAborted();
+		if (!warnings?.has(placement.machine)) {
+			warn(context, placement.machine, error);
+			warnings?.add(placement.machine);
+		}
+		return false;
+	} finally {
+		context?.signal.removeEventListener("abort", cancel);
+		host?.connection.close();
+	}
+}
+function followHostedMacosLogs(root, { failing = false, intervalMs = 500, retryMs = 5e3, slot, platform = "ios", context } = {}) {
+	let host;
+	const controller = new AbortController();
+	const signal = context ? AbortSignal.any([context.signal, controller.signal]) : controller.signal;
+	const cancel = () => host?.connection.close();
+	signal.addEventListener("abort", cancel, { once: true });
+	let retryAt = 0;
+	let stopped = false;
+	let running = false;
+	const tick = async () => {
+		if (running || stopped || signal.aborted || Date.now() < retryAt) return;
+		running = true;
+		try {
+			const placement = slot !== void 0 ? (platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))[slot] : readMacosRecord(root)?.host;
+			if (!placement) {
+				host?.connection.close();
+				host = void 0;
+				return;
+			}
+			host ??= await connectHost(placement.machine, void 0, false, signal);
+			if (slot !== void 0) await pullHostedNativeLogs(root, slot, placement, host, false, platform, signal);
+			else await pullHostedMacosLogs(root, placement, host, void 0, void 0, false, signal);
+			failing = false;
+		} catch (error) {
+			host?.connection.close();
+			host = void 0;
+			if (signal.aborted) return;
+			if (!failing) warn(context, (slot !== void 0 ? (platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))[slot] : readMacosRecord(root)?.host)?.machine ?? "the host", error);
+			failing = true;
+			retryAt = Date.now() + retryMs;
+		} finally {
+			running = false;
+		}
+	};
+	const timer = setInterval(() => void tick(), intervalMs);
+	return () => {
+		stopped = true;
+		controller.abort();
+		signal.removeEventListener("abort", cancel);
+		clearInterval(timer);
+		host?.connection.close();
+	};
+}
+async function syncHostedLogs(root, context) {
+	const macos = readMacosRecord(root)?.host;
+	const warnings = /* @__PURE__ */ new Set();
+	return (await Promise.all([
+		...macos ? [syncHostedMacosLogs(root, macos, void 0, warnings, "ios", context)] : [],
+		...Object.entries(readHostedIos(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings, "ios", context)),
+		...Object.entries(readHostedAndroid(root)).map(([slot, placement]) => syncHostedMacosLogs(root, placement, slot, warnings, "android", context))
+	])).every(Boolean);
+}
+function followHostedLogs(root, failing, context) {
+	const stops = /* @__PURE__ */ new Map();
+	let closed = false;
+	const refresh = () => {
+		if (closed) return;
+		const active = /* @__PURE__ */ new Set();
+		if (readMacosRecord(root)?.host) {
+			active.add("macos");
+			if (!stops.has("macos")) stops.set("macos", followHostedMacosLogs(root, {
+				failing,
+				context
+			}));
+		}
+		for (const platform of ["ios", "android"]) for (const slot of Object.keys(platform === "ios" ? readHostedIos(root) : readHostedAndroid(root))) {
+			const key = `${platform}:${slot}`;
+			active.add(key);
+			if (!stops.has(key)) stops.set(key, followHostedMacosLogs(root, {
+				failing,
+				slot,
+				platform,
+				context
+			}));
+		}
+		for (const [key, stop] of stops) {
+			if (active.has(key)) continue;
+			stop();
+			stops.delete(key);
+		}
+	};
+	const stateFile = workspaceStateFile(root);
+	const home = resolve(configDir());
+	let watcher = null;
+	const observe = () => {
+		if (closed) return;
+		watcher?.close();
+		watcher = null;
+		let directory = dirname(stateFile);
+		for (;;) try {
+			const entry = relative(directory, stateFile).split(sep)[0];
+			const next = watch(directory, (_event, name) => {
+				if (name !== null && name.toString() !== entry) return;
+				if (directory !== dirname(stateFile)) observe();
+				refresh();
+			});
+			next.on("error", () => {
+				next.close();
+				if (watcher === next) watcher = null;
+			});
+			next.unref();
+			watcher = next;
+			return;
+		} catch (error) {
+			if (directory === home || !(error instanceof Error && "code" in error && error.code === "ENOENT")) return;
+			directory = dirname(directory);
+		}
+	};
+	observe();
+	refresh();
+	const timer = setInterval(() => {
+		observe();
+		refresh();
+	}, 1e4);
+	return () => {
+		closed = true;
+		watcher?.close();
+		clearInterval(timer);
+		for (const stop of stops.values()) stop();
+	};
+}
+//#endregion
+//#region src/engine/logs.ts
+async function openWorkspaceLogs(context, options = {}, follow = false) {
+	context.signal.throwIfAborted();
+	const root = context.projectRoot;
+	const dir = workspaceLogsDir$1(root);
+	if (!logFiles(dir).length) throw Object.assign(/* @__PURE__ */ new Error(`No Stim workspace has run in ${root}. Run stim start, stim ios, or stim android in the app first.`), { code: "STIM_NO_PROJECT" });
+	const hostedReachable = await syncHostedLogs(root, context);
+	context.signal.throwIfAborted();
+	const initial = await openLogDir(dir, { signal: context.signal });
+	let attempts;
+	try {
+		attempts = initial.launchAttempts();
+	} finally {
+		await initial.close();
+	}
+	await captureWorkspaceCrashes(root, dir, attempts, context.signal, context.env);
+	const view = await openLogDir(dir, {
+		order: follow ? "name" : "timeline",
+		signal: context.signal
+	});
+	const agentSince = view.firstTs ?? (follow ? Date.now() : void 0);
+	const project = loadConfig$1()?.projects?.[root];
+	return {
+		view,
+		readAgent: (options.sources ? options.sources.includes("agent") : !options.errorsOnly) && agentSince !== void 0 ? createAsyncAgentActionReader$1({
+			targets: () => workspaceAgentTargets(project, readMacosRecord(root)),
+			sinceTs: agentSince,
+			home: context.env.HOME,
+			env: context.env
+		}, context.signal) : null,
+		hostedReachable
+	};
+}
+async function readWorkspaceLogs(context, options = {}) {
+	validateLogOptions(options);
+	const { view, readAgent } = await openWorkspaceLogs(context, options);
+	try {
+		return await view.query({
+			...options,
+			extra: await readAgent?.({
+				tail: options.tail,
+				matches: view.filter(options)
+			})
+		});
+	} finally {
+		await view.close();
+	}
+}
+function validateLogOptions(options) {
+	const invalid = (options.tail !== void 0 && (!Number.isSafeInteger(options.tail) || options.tail < 0) ? "tail must be a non-negative integer." : options.sources?.some((source) => !SOURCES.includes(source)) ? `sources must contain only ${SOURCES.join(", ")}.` : options.minLevel !== void 0 && !LEVELS.includes(options.minLevel) ? `minLevel must be one of ${LEVELS.join(", ")}.` : void 0) ?? (options.since !== void 0 ? parseSince(options.since).error : void 0) ?? (options.grep !== void 0 ? compileGrep(options.grep).error : void 0);
+	if (invalid) throw Object.assign(new Error(invalid), { code: "STIM_BAD_ARG" });
+}
+async function followWorkspaceLogs(context, options, onRecord, onBackfill) {
+	validateLogOptions(options);
+	const { view, readAgent, hostedReachable } = await openWorkspaceLogs(context, options, true);
+	try {
+		const query = {
+			...options,
+			extra: await readAgent?.({
+				tail: options.tail,
+				matches: view.filter(options)
+			})
+		};
+		if (onBackfill && options.tail === void 0) for await (const batch of view.batches(query)) {
+			await onBackfill(batch);
+			context.signal.throwIfAborted();
+		}
+		else {
+			const records = await view.query(query);
+			context.signal.throwIfAborted();
+			if (onBackfill) await onBackfill(records);
+			else for (const record of records) onRecord(record);
+		}
+	} catch (error) {
+		await view.close();
+		throw error;
+	}
+	const criteria = buildCriteria(options);
+	const stopLog = followLogs({
+		dir: workspaceLogsDir$1(context.projectRoot),
+		offsets: view.sizes,
+		criteria,
+		onRecord,
+		errorContext: options.errorsOnly ? "field" : void 0
+	});
+	await view.close();
+	const stopAgent = readAgent ? followAgentActions(context, readAgent, (record) => {
+		if (recordMatches(record, criteria)) onRecord(record);
+	}) : null;
+	const stopHosted = followHostedLogs(context.projectRoot, !hostedReachable, context);
+	const stop = () => {
+		stopLog();
+		stopHosted();
+		stopAgent?.();
+		context.signal.removeEventListener("abort", stop);
+	};
+	context.signal.addEventListener("abort", stop, { once: true });
+	if (context.signal.aborted) stop();
+	return stop;
+}
+//#endregion
+export { followAgentActions as a, followHostedLogs as i, openWorkspaceLogs as n, readWorkspaceLogs as r, followWorkspaceLogs as t };