stim 1.10.0 → 1.11.0

package/dist/{ios-B2Fpqvlb.mjs → ios-DArbmwer.mjs}

@@ -1,7 +1,7 @@
 import { g as loadConfig$1 } from "./config-BEq0Qw_a.mjs";
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { J as recordCreatedDevice, K as isStimOwnedSim, q as forgetCreatedDevice } from "./android-787HhP5w.mjs";
+import { X as forgetCreatedDevice, Y as isStimOwnedSim, Z as recordCreatedDevice } from "./android-C4zG2Tuc.mjs";
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { IOS_SIMULATOR_APPS } from "@stim-cli/core/state";
 import { dirname, join, resolve } from "node:path";
@@ -42,6 +42,7 @@ function configuredIosSimulatorViewer(override) {
 	const exec = getExecutor();
 	if (app === "stim-desktop") return { open: (udid) => {
 		exec.runFileQuiet("open", [
+			"-g",
 			"-a",
 			"Stim",
 			`stim-desktop://open?udid=${udid}`
@@ -300,16 +301,24 @@ function rankIphone(name) {
 function iosRuntimeMatches(runtime, requested) {
 	return runtime.version === requested || runtime.name === requested;
 }
+function bestIphone(candidates) {
+	return candidates.toSorted((a, b) => {
+		const ra = rankIphone(a.name), rb = rankIphone(b.name);
+		return rb.gen - ra.gen || rb.variant - ra.variant || b.name.localeCompare(a.name, void 0, { numeric: true });
+	})[0];
+}
 function pickDefaultIosCreation(_deviceTypes, runtimes, { deviceType, runtime } = {}) {
 	const rts = runtimes.toSorted((a, b) => String(b.version).localeCompare(String(a.version), void 0, { numeric: true }));
 	const wantedRts = runtime ? rts.filter((r) => iosRuntimeMatches(r, runtime)) : rts;
+	if (!deviceType) for (const rt of wantedRts) {
+		const best = bestIphone((rt.supportedDeviceTypes || []).filter((d) => /^iPhone/i.test(d.name) && rankIphone(d.name).gen >= 0));
+		if (best !== void 0) return {
+			deviceTypeId: best.identifier,
+			runtimeId: rt.identifier
+		};
+	}
 	for (const rt of wantedRts) {
-		const supported = (rt.supportedDeviceTypes || []).filter((d) => deviceType ? d.name === deviceType : /^iPhone/i.test(d.name));
-		if (supported.length === 0) continue;
-		const best = supported.toSorted((a, b) => {
-			const ra = rankIphone(a.name), rb = rankIphone(b.name);
-			return rb.gen - ra.gen || rb.variant - ra.variant || b.name.localeCompare(a.name, void 0, { numeric: true });
-		})[0];
+		const best = bestIphone((rt.supportedDeviceTypes || []).filter((d) => deviceType ? d.name === deviceType : /^iPhone/i.test(d.name)));
 		if (best === void 0) continue;
 		return {
 			deviceTypeId: best.identifier,

package/dist/{ios-device-CtRdEVjx.mjs → ios-device-CwDZo0X4.mjs}

@@ -1,6 +1,6 @@
 import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
 import { n as TOOL_ERROR_PREFIX } from "./ios-device-BiOsSVzd.mjs";
-import { i as INSTALL_ERROR } from "./app-install-CrJ6t_bv.mjs";
+import { i as INSTALL_ERROR } from "./app-install-DHut6JnV.mjs";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";

package/dist/{launch-verify-CQS_Kg-C.mjs → launch-verify-CuPDGXdr.mjs}

@@ -2,7 +2,7 @@ import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
 import { o as readNdjsonGenerations } from "./ndjson-CDY9IkVC.mjs";
 import { s as isAppLaunchError } from "./command-output-D5z2_bcF.mjs";
 import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-BiOsSVzd.mjs";
-import { d as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, o as androidAppProcess } from "./app-install-CrJ6t_bv.mjs";
+import { d as deviceShellArg, n as ANDROID_DISABLE_AUTO_LAUNCH_EXTRA, o as androidAppProcess } from "./app-install-DHut6JnV.mjs";
 import { join } from "node:path";
 //#region src/engine/app-readiness.ts
 const APP_READINESS_TIMEOUT_MS = 3e4;

package/dist/logs-B44a1UeU.mjs

@@ -0,0 +1,485 @@
+import { D as process_identity_exports, H as projectDeviceSlots, V as parseDeviceSlotOption, g as loadConfig$1, h as isPathPrefix } from "./config-BEq0Qw_a.mjs";
+import { n as SOURCES, t as LEVELS } from "./ndjson-CDY9IkVC.mjs";
+import { j as workspaceLogsDir, m as readWorkspaceState$1 } from "./metro-BWLOJ_Wr.mjs";
+import { o as findProjectRoot } from "./project-BXZzOABt.mjs";
+import { f as refuseNoProject, v as launchErrorPreview } from "./command-output-D5z2_bcF.mjs";
+import { i as readAgentDeviceRecords, t as agentDeviceLiveness } from "./activity-BtG4Va9l.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-UYFSQwRy.mjs";
+import { closeSync, fstatSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { buildCriteria, compileGrep, fileSizes, followLogs, logFiles, parseSince, queryLogs, readLogRecords, recordMatches, sortByTs } from "@stim-cli/core/state";
+import { join, relative, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+import chalk from "chalk";
+//#region src/devices/agent-actions.ts
+const EVENTS_VERSION = 1;
+function object(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseAgentEvents(lines) {
+	const events = [];
+	let session = null;
+	let unknownVersion = null;
+	for (const line of lines) {
+		let entry;
+		try {
+			entry = object(JSON.parse(line));
+		} catch {
+			continue;
+		}
+		if (!entry) continue;
+		const ts = typeof entry.ts === "string" ? Date.parse(entry.ts) : NaN;
+		if (entry.version !== EVENTS_VERSION) {
+			unknownVersion ??= {
+				version: entry.version,
+				ts: Number.isFinite(ts) ? ts : null
+			};
+			continue;
+		}
+		if (typeof entry.session === "string") session ??= entry.session;
+		const { kind, command, summary } = entry;
+		if (kind !== "action.recorded" && kind !== "request.finished") continue;
+		const failed = kind === "request.finished" && entry.status === "error";
+		if (kind === "request.finished" && !failed) continue;
+		if (!Number.isFinite(ts) || typeof entry.session !== "string" || typeof command !== "string") continue;
+		if (typeof summary !== "string") continue;
+		events.push({
+			ts,
+			session: entry.session,
+			kind,
+			command,
+			summary,
+			failed,
+			details: object(entry.details)
+		});
+	}
+	return {
+		events,
+		session,
+		unknownVersion
+	};
+}
+const RUNNER_DEVICE = /-destination\s+"?platform=iOS Simulator,id=([^",\s]+)|AgentDeviceRunner\.env\.session-(.+?)-owner-/;
+const LOG_TIME = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})(\.\d+)?([+-]\d{2})?(\d{2})?\b/;
+function logTime(line) {
+	const match = LOG_TIME.exec(line);
+	if (!match) return null;
+	const [, date, time, fraction = "", offsetHours, offsetMinutes] = match;
+	const offset = offsetHours && offsetMinutes ? `${offsetHours}:${offsetMinutes}` : "";
+	const at = Date.parse(`${date}T${time}${fraction.slice(0, 4)}${offset}`);
+	return Number.isFinite(at) ? at : null;
+}
+function parseRunnerSpans(text) {
+	const spans = [];
+	let pending = null;
+	for (const line of text.split("\n")) {
+		const device = RUNNER_DEVICE.exec(line);
+		if (device) {
+			pending = device[1] ?? device[2] ?? null;
+			continue;
+		}
+		if (pending === null) continue;
+		const at = logTime(line);
+		if (at === null) continue;
+		if (spans.at(-1)?.deviceId !== pending) spans.push({
+			deviceId: pending,
+			from: spans.length ? at : -Infinity
+		});
+		pending = null;
+	}
+	return spans;
+}
+function sessionSpans(runner, closes) {
+	return runner.map((span, i) => {
+		const previous = runner[i - 1]?.from ?? -Infinity;
+		const close = closes.findLast((at) => at > previous && at < span.from);
+		return close === void 0 ? span : {
+			...span,
+			from: close + 1
+		};
+	});
+}
+function spanDevice(spans, ts) {
+	let device = null;
+	for (const span of spans) if (span.from <= ts) device = span.deviceId;
+	return device;
+}
+function agentRecord(event, deviceId, target) {
+	return {
+		ts: event.ts,
+		src: "agent",
+		level: event.failed ? "error" : "info",
+		msg: event.summary,
+		event: event.failed ? "agent_failed" : "agent_action",
+		command: event.command,
+		session: event.session,
+		platform: target.platform,
+		deviceId,
+		...target.slot === "default" ? {} : { slot: target.slot },
+		...event.details ? { details: event.details } : {}
+	};
+}
+function formatUnknownRecord(session, unknown, target, now) {
+	return {
+		ts: unknown.ts ?? now,
+		src: "agent",
+		level: "warn",
+		msg: `agent-device session ${session} records events in an unrecognized format (version ${JSON.stringify(unknown.version) ?? "missing"}); its actions are not shown.`,
+		event: "agent_format_unknown",
+		session,
+		platform: target.platform,
+		...target.slot === "default" ? {} : { slot: target.slot }
+	};
+}
+function workspaceAgentTargets(project) {
+	const targets = [];
+	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 envDir(name) {
+	const value = process.env[name]?.trim();
+	return value ? resolve(value) : null;
+}
+function readCompleteLines(path, start) {
+	let fd;
+	try {
+		fd = openSync(path, "r");
+		const size = fstatSync(fd).size;
+		if (size <= start) return {
+			text: "",
+			next: start,
+			size
+		};
+		const buffer = Buffer.alloc(size - start);
+		const read = readSync(fd, buffer, 0, buffer.length, start);
+		const end = buffer.subarray(0, read).lastIndexOf(10);
+		return {
+			text: end < 0 ? "" : buffer.toString("utf8", 0, end + 1),
+			next: start + end + 1,
+			size
+		};
+	} catch {
+		return null;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+/**
+* Returns a reader of agent-device actions on the given devices. Each call returns the records written
+* since the previous call; the first call returns the retained history newer than `sinceTs`. It only reads
+* agent-device's state directory, and any file it cannot read or recognize yields no records.
+*/
+function createAgentActionReader({ targets, sinceTs = -Infinity, home = homedir(), now = Date.now, startOf = process_identity_exports.inspectProcessStart }) {
+	const sessionsDir = join(envDir("AGENT_DEVICE_STATE_DIR") ?? join(home, ".agent-device"), "sessions");
+	const cursors = /* @__PURE__ */ new Map();
+	const byId = new Map(targets.map((target) => [target.id, target]));
+	return () => {
+		if (!targets.length) return [];
+		let names;
+		try {
+			names = readdirSync(sessionsDir);
+		} catch {
+			return [];
+		}
+		let claimed;
+		const claimedDevice = (session) => (claimed ??= new Map(readAgentDeviceRecords(home).filter((record) => record.kind === "claim" && record.session && record.deviceId).filter((record) => {
+			const target = byId.get(record.deviceId);
+			return target?.name === void 0 || target.name === record.deviceName;
+		}).filter((record) => agentDeviceLiveness(record, startOf) === "live").map((record) => [record.session, record.deviceId]))).get(session) ?? null;
+		const out = [];
+		for (const name of names) {
+			const dir = join(sessionsDir, name);
+			const eventsPath = join(dir, "events.ndjson");
+			const lines = [];
+			let cursor = cursors.get(name);
+			if (!cursor) {
+				try {
+					if (statSync(eventsPath).mtimeMs < sinceTs) continue;
+				} catch {
+					continue;
+				}
+				cursor = {
+					offset: 0,
+					closes: [],
+					runner: null,
+					session: null,
+					unknownReported: false
+				};
+				cursors.set(name, cursor);
+				try {
+					lines.push(...readFileSync(`${eventsPath}.1`, "utf8").split("\n"));
+				} catch {}
+			}
+			let chunk = readCompleteLines(eventsPath, cursor.offset);
+			if (chunk && chunk.size < cursor.offset) chunk = readCompleteLines(eventsPath, 0);
+			if (!chunk) continue;
+			cursor.offset = chunk.next;
+			lines.push(...chunk.text.split("\n"));
+			const parsed = parseAgentEvents(lines);
+			cursor.session ??= parsed.session;
+			const session = cursor.session;
+			if (!parsed.events.length && !parsed.unknownVersion) continue;
+			const runnerPath = join(dir, "runner.log");
+			let runnerSize = -1;
+			try {
+				runnerSize = statSync(runnerPath).size;
+			} catch {}
+			if (cursor.runner?.size !== runnerSize) {
+				let text = "";
+				try {
+					text = readFileSync(runnerPath, "utf8");
+				} catch {}
+				cursor.runner = {
+					size: runnerSize,
+					spans: parseRunnerSpans(text)
+				};
+			}
+			for (const event of parsed.events) if (event.command === "close" && !event.failed) cursor.closes.push(event.ts);
+			const spans = sessionSpans(cursor.runner.spans, cursor.closes);
+			const deviceAt = (ts) => spans.length ? spanDevice(spans, ts) : session && claimedDevice(session);
+			if (parsed.unknownVersion && !cursor.unknownReported) {
+				const deviceId = spans.at(-1)?.deviceId ?? (session && claimedDevice(session));
+				const target = deviceId ? byId.get(deviceId) : void 0;
+				if (target) {
+					cursor.unknownReported = true;
+					out.push(formatUnknownRecord(session ?? name, parsed.unknownVersion, target, now()));
+				}
+			}
+			for (const event of parsed.events) {
+				if (event.ts < sinceTs) continue;
+				const deviceId = deviceAt(event.ts);
+				const target = deviceId ? byId.get(deviceId) : void 0;
+				if (target && deviceId) out.push(agentRecord(event, deviceId, target));
+			}
+		}
+		return out.toSorted((a, b) => a.ts - b.ts);
+	};
+}
+//#endregion
+//#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] };
+	const unknown = list.filter((s) => !SOURCES.includes(s));
+	if (unknown.length > 0) return { error: `Unknown --source value(s): ${unknown.join(", ")}. Use one or more of: ${SOURCES.join(", ")}, or all.` };
+	return { sources: list };
+}
+function validateLevel(level) {
+	if (LEVELS.includes(level)) return { level };
+	return { error: `Invalid --level value ${JSON.stringify(level)}. Use one of: ${LEVELS.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(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-device actions). Prints and exits; an existing timeline with nothing matching is a successful, empty result. Use --follow to stream.").option("--slot <name>", "Only records attributed to this device slot", parseDeviceSlotOption).option("--source <s...>", "Only these sources: metro, client, device, build, agent, or all").option("--level <l>", `Minimum level: ${LEVELS.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. Add --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 = findProjectRoot(process.cwd());
+		if (!root) {
+			refuseNoProject({ json: false });
+			return;
+		}
+		const dir = workspaceLogsDir(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 captured = captureWorkspaceCrashes(root, dir);
+		const offsets = opts.follow ? fileSizes(dir) : null;
+		const workspaceTimeline = opts.follow ? readLogRecords(dir) : captured;
+		const agentSince = workspaceTimeline[0]?.ts ?? (opts.follow ? Date.now() : void 0);
+		const readAgent = (sources ? sources.includes("agent") : !opts.errors) && agentSince !== void 0 ? createAgentActionReader({
+			targets: workspaceAgentTargets(loadConfig$1()?.projects?.[root]),
+			sinceTs: agentSince
+		}) : null;
+		const timeline = readAgent ? sortByTs([...workspaceTimeline, ...readAgent()]) : workspaceTimeline;
+		const rawRecords = queryLogs({
+			...query,
+			records: timeline
+		});
+		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
+		});
+		const agentTimer = readAgent ? setInterval(() => {
+			for (const record of readAgent()) if (recordMatches(record, criteria)) emit(record);
+		}, 500) : null;
+		const finish = () => {
+			stop();
+			if (agentTimer) clearInterval(agentTimer);
+			process.exit(0);
+		};
+		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 };