stim 1.0.0 → 1.1.0

package/dist/ios-device-CYbuRNXR.mjs

@@ -0,0 +1,81 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+//#region src/collector/ios-device.ts
+const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
+const DEV_MENU_LAUNCH_ARGS = [
+	"-EXDevMenuShowsAtLaunch",
+	"0",
+	"-EXDevMenuShowFloatingActionButton",
+	"0"
+];
+const FATAL_MARKERS = [
+	/^\*\*\* Terminating app due to uncaught exception/,
+	/^libc\+\+abi: terminating/,
+	/^\*\*\* Assertion failure in/,
+	/^(?:\S+:\d+: )?Fatal error: /
+];
+const MIRROR_LINE = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+[+-]\d{4}) (.+?)\[(\d+):(\d+)\] ?(?:\[([^\]\s]+)\] )?([\s\S]*)$/;
+function deviceConsoleLevel(message) {
+	const text = typeof message === "string" ? message : "";
+	return FATAL_MARKERS.some((marker) => marker.test(text)) ? "fatal" : "info";
+}
+function parseDeviceConsoleLine(line, { now = Date.now } = {}) {
+	if (typeof line !== "string") return null;
+	const text = line.replace(/\r$/, "").trimEnd();
+	if (!text.trim()) return null;
+	const match = MIRROR_LINE.exec(text);
+	const record = {
+		ts: now(),
+		src: "device",
+		level: "info",
+		msg: text,
+		raw: true
+	};
+	if (!match) {
+		record.level = text.startsWith("ERROR: ") ? "error" : deviceConsoleLevel(text);
+		return record;
+	}
+	const [, timestamp, proc, pid, , category, message] = match;
+	if (message === void 0 || !message.trim()) return null;
+	const parsed = Date.parse(timestamp);
+	if (Number.isFinite(parsed)) record.ts = parsed;
+	record.msg = message;
+	record.level = deviceConsoleLevel(message);
+	record.proc = `${proc}(${pid})`;
+	if (category) record.category = category;
+	return record;
+}
+function deviceConsoleArgs({ udid, bundleId, payloadUrl = null }) {
+	const args = [
+		"devicectl",
+		"device",
+		"process",
+		"launch",
+		"--quiet",
+		"--device",
+		udid,
+		"--console",
+		"--terminate-existing",
+		"--environment-variables",
+		JSON.stringify(CONSOLE_ENV)
+	];
+	if (payloadUrl) args.push("--payload-url", payloadUrl);
+	args.push(bundleId);
+	if (payloadUrl) args.push("--", ...DEV_MENU_LAUNCH_ARGS);
+	return args;
+}
+function startIosDeviceConsole({ udid, bundleId, payloadUrl = null, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("xcrun", deviceConsoleArgs({
+		udid,
+		bundleId,
+		payloadUrl
+	}), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+//#endregion
+export { startIosDeviceConsole as i, deviceConsoleLevel as n, parseDeviceConsoleLine as r, DEV_MENU_LAUNCH_ARGS as t };

package/dist/ios-device-CdSm0GDw.mjs

@@ -0,0 +1,413 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { r as INSTALL_ERROR } from "./app-install-oZIQRbdD.mjs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/engine/ios-device.ts
+const DEVICECTL_TIMEOUT_MS = 3e4;
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function parseDevicectlDevices(payload) {
+	let data = payload;
+	if (typeof payload === "string") try {
+		data = JSON.parse(payload);
+	} catch {
+		return [];
+	}
+	const devices = record(record(data).result).devices;
+	if (!Array.isArray(devices)) return [];
+	const out = [];
+	for (const raw of devices) {
+		const entry = record(raw);
+		const hardware = record(entry.hardwareProperties);
+		const properties = record(entry.deviceProperties);
+		const connection = record(entry.connectionProperties);
+		const udid = text(hardware.udid);
+		if (!udid) continue;
+		out.push({
+			udid,
+			name: text(properties.name) ?? udid,
+			bootState: text(properties.bootState),
+			developerModeStatus: text(properties.developerModeStatus),
+			pairingState: text(connection.pairingState),
+			transportType: text(connection.transportType)
+		});
+	}
+	return out;
+}
+function listIosDevices({ exec = null } = {}) {
+	const executor = exec || getExecutor();
+	const dir = mkdtempSync(join(tmpdir(), "stim-devicectl-"));
+	const out = join(dir, "devices.json");
+	try {
+		executor.runFile("xcrun", [
+			"devicectl",
+			"list",
+			"devices",
+			"-j",
+			out
+		], { timeoutMs: DEVICECTL_TIMEOUT_MS });
+		return parseDevicectlDevices(readFileSync(out, "utf-8"));
+	} catch {
+		return [];
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const DEVELOPER_MODE_REMEDY = "Turn on Settings > Privacy & Security > Developer Mode on the phone, restart it, then reconnect.";
+const PAIRING_REMEDY = "Unlock the phone, tap Trust on the pairing prompt, then reconnect the cable.";
+const CABLE_REMEDY = "Connect the phone with a cable and check `xcrun devicectl list devices`, then retry.";
+const WIRED_TRANSPORTS = /* @__PURE__ */ new Set(["wired", "usb"]);
+function isWired(device) {
+	return device.transportType === null || WIRED_TRANSPORTS.has(device.transportType.toLowerCase());
+}
+function describe(device) {
+	return `${device.udid} (${device.name})`;
+}
+function wirelessRefusal(device) {
+	return {
+		error: `${describe(device)} is paired over ${device.transportType}, not a cable, and Stim installs over the cable only.`,
+		remedy: CABLE_REMEDY
+	};
+}
+function unhealthy(device) {
+	if (device.pairingState !== null && device.pairingState.toLowerCase() !== "paired") return {
+		error: `${describe(device)} is connected but ${device.pairingState}, so devicectl cannot drive it.`,
+		remedy: PAIRING_REMEDY
+	};
+	if (device.developerModeStatus !== null && device.developerModeStatus.toLowerCase() !== "enabled") return {
+		error: `${describe(device)} has Developer Mode ${device.developerModeStatus}, so it will not run a development build.`,
+		remedy: DEVELOPER_MODE_REMEDY
+	};
+	return null;
+}
+function iosPoolCandidates(devices) {
+	return (Array.isArray(devices) ? devices : []).filter((device) => isWired(device) && unhealthy(device) === null);
+}
+function iosPoolNoCandidatesRefusal(devices) {
+	const listed = Array.isArray(devices) ? devices : [];
+	const cabled = listed.filter(isWired);
+	const problems = cabled.map((device) => unhealthy(device));
+	if (cabled.length > 0 && problems.every((problem) => problem !== null)) {
+		const reasons = problems;
+		return {
+			error: reasons.map((reason) => reason.error).join(" "),
+			remedy: [...new Set(reasons.map((reason) => reason.remedy))].join(" ")
+		};
+	}
+	return resolveIosPhysicalDevice(null, listed);
+}
+function resolveIosPhysicalDevice(requested, devices) {
+	const listed = Array.isArray(devices) ? devices : [];
+	const cabled = listed.filter(isWired);
+	const wireless = listed.filter((d) => !isWired(d));
+	if (requested) {
+		const match = cabled.find((d) => d.udid.toLowerCase() === requested.toLowerCase());
+		if (match) return unhealthy(match) ?? {
+			udid: match.udid,
+			name: match.name
+		};
+		const overNetwork = wireless.find((d) => d.udid.toLowerCase() === requested.toLowerCase());
+		if (overNetwork) return wirelessRefusal(overNetwork);
+		return {
+			error: cabled.length ? `${requested} is not connected. devicectl reports these cabled devices: ${cabled.map(describe).join(", ")}.` : `${requested} is not connected by cable, and devicectl reports no cabled device at all.`,
+			remedy: "Check the cable and `xcrun devicectl list devices`, then retry with a UDID it lists."
+		};
+	}
+	if (cabled.length === 1) {
+		const only = cabled[0];
+		return unhealthy(only) ?? {
+			udid: only.udid,
+			name: only.name
+		};
+	}
+	if (cabled.length > 1) return {
+		error: `Several devices are connected: ${cabled.map(describe).join(", ")}.`,
+		remedy: "Name the one to build for with `stim ios --device <udid>`."
+	};
+	const onlyWireless = wireless[0];
+	if (onlyWireless) return wirelessRefusal(onlyWireless);
+	return {
+		error: "No physical iOS device is connected.",
+		remedy: "Plug the phone in, unlock it, tap Trust, turn on Settings > Privacy & Security > Developer Mode, then check `xcrun devicectl list devices`."
+	};
+}
+const DEVICECTL_INSTALL_TIMEOUT_MS = 3e5;
+const LOCKED_REMEDY = "Unlock the phone and keep it awake, then run the command again.";
+function errorText(error) {
+	const withOutput = error;
+	const stderr = String(withOutput?.stderr ?? "").trim();
+	const stdout = String(withOutput?.stdout ?? "").trim();
+	return [
+		String(withOutput?.message ?? error).trim(),
+		stderr,
+		stdout
+	].filter(Boolean).join("\n");
+}
+function iosInstallFailureKind(output) {
+	const out = String(output ?? "");
+	if (/MismatchedApplicationIdentifierEntitlement|application-identifier entitlement[^\n]*does not match/i.test(out)) return "signer";
+	if (/device is locked|is locked\b|passcode/i.test(out)) return "locked";
+	if (/not paired|pairing|trust this computer|untrusted host/i.test(out)) return "untrusted-host";
+	if (/developer mode/i.test(out)) return "developer-mode";
+	if (/not enough (?:free )?(?:disk )?space|insufficient (?:disk )?space|storage is full/i.test(out)) return "storage";
+	return null;
+}
+function iosInstallRemedy(kind, { udid, bundleId }) {
+	switch (kind) {
+		case "signer": return `${bundleId ?? "The app"} is already installed on ${udid} under a different team, and Stim could not remove it. Delete the app on the phone (its data goes with it), then run the command again.`;
+		case "locked": return LOCKED_REMEDY;
+		case "untrusted-host": return "Unlock the phone, tap Trust on the pairing prompt, then run the command again.";
+		case "developer-mode": return "Turn on Settings > Privacy & Security > Developer Mode on the phone, restart it, then run the command again.";
+		case "storage": return "Free space on the phone (Settings > General > iPhone Storage), then run the command again.";
+		default: return `Check that ${udid} is still connected and unlocked (\`xcrun devicectl list devices\`), and that the app was built for the iphoneos SDK.`;
+	}
+}
+function installIosDeviceApp({ udid, appPath, bundleId = null }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	const install = () => {
+		e.runFile("xcrun", [
+			"devicectl",
+			"device",
+			"install",
+			"app",
+			"--device",
+			udid,
+			appPath
+		], { timeoutMs: DEVICECTL_INSTALL_TIMEOUT_MS });
+	};
+	try {
+		install();
+		return {
+			ok: true,
+			appPath
+		};
+	} catch (err) {
+		const failure = errorText(err);
+		const kind = iosInstallFailureKind(failure);
+		if (kind !== "signer" || !bundleId) return {
+			failed: true,
+			code: INSTALL_ERROR,
+			reason: `devicectl could not install ${appPath} on ${udid}: ${failure}`,
+			remedy: iosInstallRemedy(kind, {
+				udid,
+				bundleId
+			})
+		};
+		try {
+			e.runFile("xcrun", [
+				"devicectl",
+				"device",
+				"uninstall",
+				"app",
+				"--device",
+				udid,
+				bundleId
+			], { timeoutMs: DEVICECTL_INSTALL_TIMEOUT_MS });
+		} catch (uninstallErr) {
+			return {
+				failed: true,
+				code: INSTALL_ERROR,
+				reason: `devicectl refused to install ${appPath} over the copy of ${bundleId} already on ${udid}, which a different team signed, and the uninstall failed too: ${errorText(uninstallErr)}`,
+				remedy: iosInstallRemedy("signer", {
+					udid,
+					bundleId
+				})
+			};
+		}
+		try {
+			install();
+		} catch (retryErr) {
+			return {
+				failed: true,
+				code: INSTALL_ERROR,
+				reason: `devicectl could not install ${appPath} on ${udid} even after uninstalling ${bundleId}: ${errorText(retryErr)}`,
+				remedy: iosInstallRemedy(null, {
+					udid,
+					bundleId
+				})
+			};
+		}
+		return {
+			ok: true,
+			appPath,
+			uninstalled: true,
+			note: `${bundleId} was already installed on ${udid} under a different team, so it was uninstalled (its data went with it) before this app could be installed. An uninstall also clears the phone's developer trust and its Local Network permission, so the launch below may need Settings > General > VPN & Device Management again`
+		};
+	}
+}
+function parseDeviceProcesses(payload) {
+	let data = payload;
+	if (typeof payload === "string") try {
+		data = JSON.parse(payload);
+	} catch {
+		return [];
+	}
+	const running = record(record(data).result).runningProcesses;
+	if (!Array.isArray(running)) return [];
+	const out = [];
+	for (const raw of running) {
+		const entry = record(raw);
+		const pid = Number(entry.processIdentifier);
+		const executable = text(entry.executable);
+		if (!Number.isInteger(pid) || pid <= 0 || !executable) continue;
+		out.push({
+			pid,
+			executable
+		});
+	}
+	return out;
+}
+function deviceProcessPid(processes, appName) {
+	const marker = `/${appName}.app/`;
+	for (const entry of processes) if (entry.executable.includes(marker)) return entry.pid;
+	return null;
+}
+function iosDeviceProcess({ udid, appName }, { exec = null } = {}) {
+	const executor = exec || getExecutor();
+	const dir = mkdtempSync(join(tmpdir(), "stim-devicectl-"));
+	const out = join(dir, "processes.json");
+	try {
+		executor.runFile("xcrun", [
+			"devicectl",
+			"device",
+			"info",
+			"processes",
+			"--device",
+			udid,
+			"--quiet",
+			"--json-output",
+			out
+		], { timeoutMs: DEVICECTL_TIMEOUT_MS });
+		return deviceProcessPid(parseDeviceProcesses(readFileSync(out, "utf-8")), appName);
+	} catch {
+		return;
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const LAUNCH_REFUSALS = [
+	["untrusted-developer", /profile has not been explicitly trusted by the user/i],
+	["untrusted-developer", /FBSOpenApplicationErrorDomain error 3\b/],
+	["untrusted-developer", /denied by service delegate[^\n]*for reason: Security/],
+	["locked", /device is locked|is locked\b|passcode/i],
+	["not-installed", /(?:application|app)[^\n]*\b(?:is )?(?:unknown to FrontBoard|not installed)/i]
+];
+function iosLaunchRefusalKind(output) {
+	for (const line of String(output ?? "").split(/\r?\n/)) for (const [kind, pattern] of LAUNCH_REFUSALS) if (pattern.test(line)) return kind;
+	return null;
+}
+function iosLaunchRemedy(kind, { udid, bundleId }) {
+	switch (kind) {
+		case "untrusted-developer": return "The phone has not trusted this build's developer certificate, which it refuses to do without a human. On the phone open Settings > General > VPN & Device Management, tap the developer profile under DEVELOPER APP, tap Trust, then run the command again.";
+		case "locked": return LOCKED_REMEDY;
+		case "not-installed": return `${bundleId} is not installed on ${udid} any more. Run the command again to install it.`;
+		default: return `Run \`xcrun devicectl device process launch --console --device ${udid} ${bundleId}\` to see what the phone reports.`;
+	}
+}
+const LAUNCH_PROBE_TIMEOUT_MS = 45e3;
+const LAUNCH_PROBE_POLL_MS = 1e3;
+const COLLECTOR_ENDED_EVENTS = /* @__PURE__ */ new Set(["collector_failed", "collector_stopped"]);
+function launchEvidence(records) {
+	const lines = [];
+	for (const entry of records) {
+		const msg = typeof entry.msg === "string" ? entry.msg.trim() : "";
+		if (!msg) continue;
+		if (entry.event === "collector_started" || entry.event === "collector_empty") continue;
+		lines.push(msg);
+	}
+	return lines.slice(-6);
+}
+function collectorRecordsFor(records, collectorPid) {
+	if (!collectorPid) return [];
+	const marker = new RegExp(`\\bcollector pid ${collectorPid}\\b`);
+	const start = records.findIndex((entry) => entry.event === "collector_started" && typeof entry.msg === "string" && marker.test(entry.msg));
+	return start < 0 ? [] : records.slice(start);
+}
+async function awaitIosDeviceLaunch({ udid, bundleId, appName, collectorPid = null, readRecords, probe, timeoutMs = LAUNCH_PROBE_TIMEOUT_MS, pollMs = LAUNCH_PROBE_POLL_MS, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+	const probeProcess = probe ?? (() => iosDeviceProcess({
+		udid,
+		appName
+	}));
+	const deadline = now() + Math.max(0, timeoutMs);
+	for (;;) {
+		const records = collectorRecordsFor(readRecords(), collectorPid);
+		const ended = records.find((entry) => typeof entry.event === "string" && COLLECTOR_ENDED_EVENTS.has(entry.event));
+		const pid = probeProcess();
+		if (typeof pid === "number") return { pid };
+		if (ended) {
+			const lines = launchEvidence(records);
+			const kind = iosLaunchRefusalKind(lines.join("\n"));
+			return {
+				failed: true,
+				reason: `devicectl could not keep ${bundleId} running on ${udid}: the console ended before the app appeared in the device's process list.`,
+				remedy: iosLaunchRemedy(kind, {
+					udid,
+					bundleId
+				}),
+				lines
+			};
+		}
+		if (now() >= deadline) {
+			const lines = launchEvidence(records);
+			return {
+				failed: true,
+				reason: `${bundleId} did not appear in ${udid}'s process list within ${Math.round(timeoutMs / 1e3)}s of the launch.`,
+				remedy: iosLaunchRemedy(iosLaunchRefusalKind(lines.join("\n")), {
+					udid,
+					bundleId
+				}),
+				lines
+			};
+		}
+		await sleep(Math.min(pollMs, Math.max(0, deadline - now())));
+	}
+}
+async function verifyIosDeviceReleaseLaunch({ udid, appName, waitMs = 3e3, probe, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+	const probeProcess = probe ?? (() => iosDeviceProcess({
+		udid,
+		appName
+	}));
+	const startedAt = now();
+	await sleep(Math.max(0, waitMs));
+	const pid = probeProcess();
+	const waitedMs = now() - startedAt;
+	if (pid === void 0) return {
+		verified: false,
+		reason: "probe-failed",
+		waitedMs
+	};
+	return pid === null ? {
+		verified: false,
+		reason: "exited",
+		waitedMs,
+		pid: null
+	} : {
+		verified: true,
+		waitedMs,
+		pid
+	};
+}
+const LOCAL_NETWORK_PROHIBITED = /_NSURLErrorNWPathKey=unsatisfied \(Local network prohibited\)/;
+function localNetworkPending(records, { since = 0, pid = null, lanOrigin }) {
+	if (!lanOrigin) return false;
+	const fromApp = pid ? new RegExp(`\\(${pid}\\)$`) : null;
+	for (const entry of records) {
+		if (Number(entry.ts) < since) continue;
+		if (fromApp && !(typeof entry.proc === "string" && fromApp.test(entry.proc))) continue;
+		if (LOCAL_NETWORK_PROHIBITED.test(typeof entry.msg === "string" ? entry.msg : "")) return true;
+	}
+	return false;
+}
+//#endregion
+export { iosDeviceProcess as a, listIosDevices as c, verifyIosDeviceReleaseLaunch as d, installIosDeviceApp as i, localNetworkPending as l, LAUNCH_PROBE_TIMEOUT_MS as n, iosPoolCandidates as o, awaitIosDeviceLaunch as r, iosPoolNoCandidatesRefusal as s, DEVICECTL_INSTALL_TIMEOUT_MS as t, resolveIosPhysicalDevice as u };

package/dist/logs-Dxoy16Qv.mjs

@@ -0,0 +1,176 @@
+import { n as SOURCES, t as LEVELS } from "./ndjson-DcAtEx_K.mjs";
+import { D as workspaceLogsDir, p as readWorkspaceState } from "./state-IYEY-zi8.mjs";
+import { a as findProjectRoot } from "./project-COj6nzzh.mjs";
+import { _ as launchErrorPreview } from "./command-output-8wHMEde0.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-B5IJwv3-.mjs";
+import { a as followLogs, i as fileSizes, n as buildCriteria, o as parseSince, r as compileGrep, s as queryLogs } from "./logs-query-oqn47Ffx.mjs";
+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] };
+	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;
+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). Prints and exits; nothing matching is a successful, empty result. Use --follow to stream.").option("--source <s...>", "Only these sources: metro, client, device, build, 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) {
+			console.error(chalk.red("Not in a React Native project (no package.json found)."));
+			process.exit(1);
+		}
+		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);
+		}
+		const query = {
+			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 offsets = opts.follow ? fileSizes(dir) : null;
+		captureWorkspaceCrashes(root, dir);
+		const rawRecords = queryLogs(query);
+		const supervisorPort = readWorkspaceState(root)?.supervisor?.port;
+		const records = opts.json ? rawRecords : await errorDiagnostics(rawRecords, {
+			root,
+			logsDir: dir,
+			port: typeof supervisorPort === "number" ? supervisorPort : null,
+			allowRequest: true
+		});
+		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({
+			sources,
+			minLevel,
+			since: opts.since,
+			grep: opts.grep,
+			errorsOnly: Boolean(opts.errors)
+		});
+		const stop = followLogs({
+			dir,
+			offsets,
+			criteria,
+			onRecord: emit
+		});
+		const finish = () => {
+			stop();
+			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 };