stim 1.20.2 → 1.21.0

package/dist/logs-BS00Anxf.mjs

@@ -0,0 +1,352 @@
+import { p as process_identity_exports } from "./exec-_UbtCQcG.mjs";
+import { m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { K as projectDeviceSlots, _ as loadConfig$1 } from "./config-CYcBF478.mjs";
+import { n as pullHostedNativeLogs, t as pullHostedMacosLogs } from "./hosted-logs-DL_P5AdN.mjs";
+import { l as phaseLine } from "./command-output-B1UrjZHL.mjs";
+import { f as readAgentDeviceRecordsAsync, n as agentDeviceLiveness } from "./activity-BzVfHSrY.mjs";
+import { l as connectHost } from "./hosted-client-DB_gBPfY.mjs";
+import { n as readHostedIos, t as readHostedAndroid } from "./ios-state-DvFX-K_l.mjs";
+import "./hosted-macos-QI141yKk.mjs";
+import { i as captureWorkspaceCrashes } from "./error-diagnostics-Bf0rZvG9.mjs";
+import { 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/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();
+	let readingAgent = false;
+	let stopped = false;
+	const agentTimer = readAgent ? setInterval(() => {
+		if (readingAgent || context.signal.aborted) return;
+		readingAgent = true;
+		readAgent().then((records) => {
+			for (const record of records) if (!stopped && !context.signal.aborted && recordMatches(record, criteria)) onRecord(record);
+		}, () => {}).finally(() => {
+			readingAgent = false;
+		});
+	}, 500) : null;
+	const stopHosted = followHostedLogs(context.projectRoot, !hostedReachable, context);
+	const stop = () => {
+		stopped = true;
+		stopLog();
+		stopHosted();
+		if (agentTimer) clearInterval(agentTimer);
+		context.signal.removeEventListener("abort", stop);
+	};
+	context.signal.addEventListener("abort", stop, { once: true });
+	if (context.signal.aborted) stop();
+	return stop;
+}
+//#endregion
+export { followHostedLogs as i, openWorkspaceLogs as n, readWorkspaceLogs as r, followWorkspaceLogs as t };

package/dist/logs-CMm05HxN.mjs

@@ -0,0 +1,255 @@
+import { m as workspaceLogsDir$1 } from "./paths-DQtTgsBf.mjs";
+import { G as parseDeviceSlotOption, _ as loadConfig$1, g as isPathPrefix } from "./config-CYcBF478.mjs";
+import { f as refuseNoProject, v as launchErrorPreview } from "./command-output-B1UrjZHL.mjs";
+import { r as readWorkspaceState$1 } from "./workspace-state-Cjuigeeu.mjs";
+import { n as findCommandWorkspace } from "./project-BZNjmW_8.mjs";
+import { n as SOURCES$1, t as LEVELS$1 } from "./ndjson-CgE_o3Dl.mjs";
+import { i as followHostedLogs, n as openWorkspaceLogs } from "./logs-BS00Anxf.mjs";
+import { t as errorDiagnostics } from "./error-diagnostics-Bf0rZvG9.mjs";
+import { t as watchStdoutReader } from "./stdout-reader-C8yjre1x.mjs";
+import { realpathSync } from "node:fs";
+import { relative, sep } from "node:path";
+import { configDir } from "@stim-cli/core";
+import { buildCriteria, compileGrep, followLogs, logFiles, parseSince, queryLogs, recordMatches, runId, sortByTs } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/logs.ts
+const LEVEL_WIDTH = 5;
+const SRC_WIDTH = 6;
+const INDENT = "    ";
+function padTimePart(value, width = 2) {
+	return String(value).padStart(width, "0");
+}
+function formatTime(ts) {
+	if (typeof ts !== "number" || !Number.isFinite(ts)) return "--:--:--.---";
+	const d = new Date(ts);
+	return `${padTimePart(d.getHours())}:${padTimePart(d.getMinutes())}:${padTimePart(d.getSeconds())}.${padTimePart(d.getMilliseconds(), 3)}`;
+}
+function formatStackFrame(frame) {
+	if (!frame || typeof frame !== "object") return null;
+	const where = [
+		frame.file,
+		frame.line,
+		frame.column
+	].filter((p) => p !== void 0 && p !== null && p !== "").join(":");
+	if (frame.fn && where) return `at ${frame.fn} (${where})`;
+	if (frame.fn) return `at ${frame.fn}`;
+	if (where) return `at ${where}`;
+	return null;
+}
+function formatRecord(record, { paint } = {}) {
+	const colour = paint || ((t) => t);
+	const level = String(record?.level ?? "").padEnd(LEVEL_WIDTH);
+	const src = String(record?.src ?? "").padEnd(SRC_WIDTH);
+	const [first, ...rest] = (record?.msg === void 0 || record?.msg === null ? "" : String(record.msg)).split("\n");
+	const lines = [`${formatTime(record?.ts)} ${colour(level)} ${src} ${first}`];
+	for (const line of rest) lines.push(`${INDENT}${line}`);
+	for (const frame of Array.isArray(record?.stack) ? record.stack : []) {
+		const rendered = formatStackFrame(frame);
+		if (rendered) lines.push(`${INDENT}${rendered}`);
+	}
+	return lines.join("\n");
+}
+function parseTail(value) {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return { n: value };
+	if (typeof value !== "string" || !/^\d+$/.test(value.trim())) return { error: `Invalid --tail value ${JSON.stringify(value)}. Use a non-negative whole number, e.g. --tail 50.` };
+	return { n: parseInt(value.trim(), 10) };
+}
+function validateSources(sources) {
+	if (sources === void 0 || sources === null) return { sources: void 0 };
+	const list = Array.isArray(sources) ? sources : [sources];
+	if (list.includes("all")) return { sources: [...SOURCES$1] };
+	const unknown = list.filter((s) => !SOURCES$1.includes(s));
+	if (unknown.length > 0) return { error: `Unknown --source value(s): ${unknown.join(", ")}. Use one or more of: ${SOURCES$1.join(", ")}, or all.` };
+	return { sources: list };
+}
+function validateLevel(level) {
+	if (LEVELS$1.includes(level)) return { level };
+	return { error: `Invalid --level value ${JSON.stringify(level)}. Use one of: ${LEVELS$1.join(", ")}.` };
+}
+const ERRORS_PRINT_CAP = 20;
+function nearestRegisteredLogsProject(root, candidates) {
+	return candidates.filter((candidate) => candidate !== root && isPathPrefix(root, candidate)).toSorted((a, b) => {
+		const depth = (path) => relative(root, path).split(sep).length;
+		return depth(a) - depth(b) || a.length - b.length || a.localeCompare(b);
+	})[0] ?? null;
+}
+function registeredDescendantWithLogs(root) {
+	const candidates = Object.keys(loadConfig$1()?.projects ?? {}).flatMap((path) => {
+		try {
+			const canonical = realpathSync(path);
+			return logFiles(workspaceLogsDir$1(canonical)).length > 0 ? [canonical] : [];
+		} catch {
+			return [];
+		}
+	});
+	return nearestRegisteredLogsProject(root, [...new Set(candidates)]);
+}
+function requireLogsWorkspace(root, dir) {
+	if (logFiles(dir).length > 0) return;
+	const descendant = registeredDescendantWithLogs(root);
+	fail(`STIM_NO_PROJECT: No Stim workspace has run in ${root}.${descendant ? ` The nearest registered app with logs is ${descendant}; run this command from there.` : " Run `stim start`, `stim ios`, or `stim android` in the app first."}`);
+}
+const LEVEL_COLOURS = {
+	debug: chalk.dim,
+	info: chalk.reset,
+	warn: chalk.yellow,
+	error: chalk.red,
+	fatal: chalk.bgRed
+};
+function logsCommand(program) {
+	program.command("logs").description("Query this workspace's merged NDJSON log timeline (bundler, client, device, build, agent actions, maintenance). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only this device slot's records, plus the shared Metro and app client records once it has launched", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, agent, maintenance, placement, or all").option("--level <l>", `Minimum level: ${LEVELS$1.join(", ")}`).option("--since <d>", "Only records newer than this, e.g. 30s, 5m, 2h").option("--grep <re>", "Only records whose message matches this regular expression").option("--tail <n>", "Only the last n matching records").option("--errors", "Errors and fatals since the last marker, from metro, client and build, plus confirmed native app-crash reports and stim web browser errors. Add --source maintenance for maintenance failures, or --source device or --source all for general device errors.").option("--follow", "Keep streaming new records until interrupted").option("--json", "Emit the raw records, one per line (valid NDJSON; zero matches is zero bytes, exit 0)").action(async (opts) => {
+		const root = findCommandWorkspace(process.cwd());
+		if (!root) {
+			refuseNoProject({ json: false });
+			return;
+		}
+		const dir = workspaceLogsDir$1(root);
+		let sources;
+		if (opts.source !== void 0) {
+			const checked = validateSources(opts.source);
+			if (checked.error) fail(checked.error);
+			sources = checked.sources;
+		}
+		let minLevel;
+		if (opts.level !== void 0) {
+			const checked = validateLevel(opts.level);
+			if (checked.error) fail(checked.error);
+			minLevel = checked.level;
+		}
+		if (opts.since !== void 0) {
+			const parsed = parseSince(opts.since);
+			if (parsed.error) fail(parsed.error);
+		}
+		let tail;
+		if (opts.tail !== void 0) {
+			const parsed = parseTail(opts.tail);
+			if (parsed.error) fail(parsed.error);
+			tail = parsed.n;
+		}
+		if (opts.grep !== void 0) {
+			const compiled = compileGrep(opts.grep);
+			if (compiled.error) fail(compiled.error);
+		}
+		requireLogsWorkspace(root, dir);
+		const query = {
+			slot: opts.slot,
+			dir,
+			sources,
+			minLevel,
+			since: opts.since,
+			grep: opts.grep,
+			tail,
+			errorsOnly: Boolean(opts.errors),
+			errorContext: Boolean(opts.errors && !opts.json && !opts.follow)
+		};
+		const emit = (record) => {
+			if (opts.json) {
+				console.log(JSON.stringify(record));
+				return;
+			}
+			const rendered = {
+				...record,
+				msg: launchErrorPreview([record], root, { full: true }).join("\n"),
+				stack: void 0
+			};
+			console.log(formatRecord(rendered, { paint: record?.level ? LEVEL_COLOURS[record.level] : void 0 }));
+		};
+		const context = {
+			home: configDir(),
+			buildCache: null,
+			projectRoot: root,
+			cwd: root,
+			runId: runId(),
+			env: process.env,
+			signal: new AbortController().signal,
+			output: (stream, text) => process[stream].write(text)
+		};
+		const { view, readAgent, hostedReachable } = await openWorkspaceLogs(context, query, Boolean(opts.follow));
+		const offsets = opts.follow ? view.sizes : null;
+		let timeline = [];
+		let rawRecords;
+		try {
+			const extra = await readAgent?.(opts.json ? {
+				tail: query.tail,
+				matches: view.filter(query)
+			} : void 0) ?? [];
+			if (opts.json) rawRecords = await view.query({
+				...query,
+				extra
+			});
+			else {
+				timeline = sortByTs([...await view.query(), ...extra]);
+				rawRecords = queryLogs({
+					...query,
+					records: timeline
+				});
+			}
+		} finally {
+			await view.close();
+		}
+		const supervisorPort = readWorkspaceState$1(root)?.supervisor?.port;
+		const records = opts.json ? rawRecords : await errorDiagnostics(rawRecords, {
+			root,
+			logsDir: dir,
+			port: typeof supervisorPort === "number" ? supervisorPort : null,
+			allowRequest: true,
+			timeline
+		});
+		const errorCount = records.filter((record) => record.errorContext !== true).length;
+		let seenErrors = 0;
+		const capped = opts.errors && !opts.json && tail === void 0 && errorCount > 20 ? records.filter((record) => {
+			if (record.errorContext === true) return seenErrors <= 20;
+			seenErrors += 1;
+			return seenErrors <= 20;
+		}) : records;
+		for (const record of capped) emit(record);
+		const hidden = errorCount - capped.filter((record) => record.errorContext !== true).length;
+		if (hidden > 0) console.log(chalk.dim(`Showing 20 of ${errorCount} matching error records; ${hidden} not shown. Add --tail ${rawRecords.length} to include all captured records before grouping, or --json for raw records. Stacks are shown in full.`));
+		if (!opts.follow) {
+			if (records.length === 0 && !opts.json) console.error(chalk.dim(`No matching log records in ${dir}`));
+			return;
+		}
+		const criteria = buildCriteria({
+			slot: opts.slot,
+			sources,
+			minLevel,
+			since: opts.since,
+			grep: opts.grep,
+			errorsOnly: Boolean(opts.errors)
+		});
+		const stop = followLogs({
+			dir,
+			offsets,
+			criteria,
+			onRecord: emit,
+			errorContext: opts.errors ? opts.json ? "field" : "msg" : void 0
+		});
+		let readingAgent = false;
+		const agentTimer = readAgent ? setInterval(() => {
+			if (readingAgent) return;
+			readingAgent = true;
+			readAgent().then((actions) => {
+				for (const record of actions) if (recordMatches(record, criteria)) emit(record);
+			}, () => {}).finally(() => {
+				readingAgent = false;
+			});
+		}, 500) : null;
+		const stopHosted = followHostedLogs(root, !hostedReachable);
+		const finish = () => {
+			stop();
+			stopHosted?.();
+			stopReader();
+			if (agentTimer) clearInterval(agentTimer);
+			process.exit(0);
+		};
+		const stopReader = watchStdoutReader(finish);
+		process.on("SIGINT", finish);
+		process.on("SIGTERM", finish);
+	});
+}
+function fail(message) {
+	console.error(chalk.red(message));
+	process.exit(1);
+}
+//#endregion
+export { ERRORS_PRINT_CAP, logsCommand as default, formatRecord, formatStackFrame, formatTime, parseTail, validateLevel, validateSources };

package/dist/{macos-D7uDvO-z.mjs → macos-B65--pPd.mjs}

@@ -1,2 +1,2 @@
-import { n as runMacos, r as waitForLaunchServices, t as macosCommand } from "./macos-Ch5VJmcS.mjs";
+import { n as runMacos, r as waitForLaunchServices, t as macosCommand } from "./macos-C-0qJ6zq.mjs";
 export { macosCommand as default, runMacos, waitForLaunchServices };