stim 1.8.0 → 1.10.0

package/dist/build-progress-BXx-ZBe4.mjs

@@ -0,0 +1,512 @@
+import { D as process_identity_exports, k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { f as clearWorkspaceStateKey, g as updateWorkspaceState, j as workspaceLogsDir, m as readWorkspaceState$1 } from "./metro-BWLOJ_Wr.mjs";
+import { a as formatElapsed, u as plural } from "./command-output-D5z2_bcF.mjs";
+import { i as listLeaseFiles, r as leaseIsExpired } from "./device-lease-CbEaIk7b.mjs";
+import { closeSync, fstatSync, openSync, readFileSync, readSync, readdirSync } from "node:fs";
+import { BUILD_PHASES } from "@stim-cli/core/state";
+import { basename, join, resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/devices/activity.ts
+const ACTIVE_WINDOW_MS = 6e5;
+const LOG_TAIL_BYTES = 262144;
+function classifyActivity(evidence, now) {
+	const last = evidence.recency.reduce((best, entry) => Number.isFinite(entry.at) && (!best || entry.at > best.at) ? entry : best, null);
+	const lastActivityAt = last ? { lastActivityAt: new Date(last.at).toISOString() } : {};
+	const [first] = evidence.drivers;
+	if (first) {
+		const { basis: _basis, ...driver } = first;
+		return {
+			state: "driven",
+			driver,
+			...lastActivityAt,
+			basis: [...new Set(evidence.drivers.map((entry) => entry.basis))]
+		};
+	}
+	if (evidence.unknown.length) return {
+		state: "unknown",
+		...lastActivityAt,
+		basis: [...new Set(evidence.unknown)]
+	};
+	return {
+		state: Boolean(last && now - last.at < ACTIVE_WINDOW_MS) ? "active" : "idle",
+		...lastActivityAt,
+		basis: [...new Set(evidence.recency.map((entry) => entry.basis))]
+	};
+}
+function idleForMs(activity, now) {
+	if (activity?.state !== "idle" || !activity.lastActivityAt) return null;
+	const at = Date.parse(activity.lastActivityAt);
+	return Number.isFinite(at) ? Math.max(0, now - at) : null;
+}
+function field(entry, pidKey, startKey) {
+	const pid = entry[pidKey];
+	const startTime = entry[startKey];
+	if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof startTime !== "string") return null;
+	return {
+		pid,
+		startTime
+	};
+}
+function parseObject(raw) {
+	if (raw === null) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseAgentDeviceRecord(kind, path, raw) {
+	const entry = parseObject(raw);
+	const stem = basename(path, ".json");
+	const device = entry?.device && typeof entry.device === "object" ? entry.device : null;
+	const recordedId = kind === "claim" ? device?.id : entry?.deviceId;
+	const deviceId = typeof recordedId === "string" && recordedId ? recordedId : kind === "runner-lease" ? stem : null;
+	const createdAtMs = typeof entry?.createdAtMs === "number" ? entry.createdAtMs : null;
+	return {
+		path,
+		kind,
+		deviceId,
+		readable: Boolean(entry && deviceId),
+		owner: entry ? field(entry, "ownerPid", "ownerStartTime") : null,
+		runner: entry && kind === "runner-lease" ? field(entry, "runnerPid", "runnerStartTime") : null,
+		createdAtMs
+	};
+}
+function processMatches(entry, startOf) {
+	const start = startOf(entry.pid);
+	if (start.status === "gone") return "dead";
+	if (start.status === "unknown") return "unknown";
+	const recorded = Date.parse(entry.startTime);
+	if (!Number.isFinite(recorded)) return "unknown";
+	return Math.floor(start.startedAtMs / 1e3) === Math.floor(recorded / 1e3) ? "live" : "dead";
+}
+function agentDeviceLiveness(record, startOf) {
+	const results = (record.kind === "claim" ? [record.owner] : [record.owner, record.runner]).map((entry) => entry ? processMatches(entry, startOf) : "unknown");
+	if (results.includes("dead")) return "dead";
+	if (!record.readable || results.includes("unknown")) return "unknown";
+	return "live";
+}
+function parseProcessTable(output) {
+	const rows = [];
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+\d{1,2}:\d{2}:\d{2}\s+\d{4})\s+(.*)$/.exec(line);
+		if (!match) continue;
+		const at = Date.parse(match[2]);
+		rows.push({
+			pid: Number(match[1]),
+			startedAt: Number.isFinite(at) ? new Date(at).toISOString() : null,
+			command: match[3]
+		});
+	}
+	return rows;
+}
+function namesDevice(command, id) {
+	const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return new RegExp(`(^|[^A-Za-z0-9])${escaped}([^A-Za-z0-9]|$)`).test(command);
+}
+function driverTool(command, id) {
+	if (!namesDevice(command, id)) return null;
+	if (/\bsimctl\s+spawn\b.*\blog\s+stream\b/.test(command) || /\blogcat\b/.test(command)) return null;
+	if (/agent-device/i.test(command)) return "agent-device";
+	if (/idb_companion/.test(command)) return "idb";
+	if (/maestro/i.test(command)) return "maestro";
+	if (/appium|WebDriverAgent/i.test(command)) return "appium";
+	if (/\bxcodebuild\b.*\btest(-without-building)?\b/.test(command)) return "xcodebuild";
+	if (/\bsimctl\s+(io|spawn)\b/.test(command)) return "simctl";
+	return null;
+}
+function parseAndroidInstrumentation(output) {
+	const found = [];
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+		if (!match) continue;
+		const args = match[2];
+		if (/uiautomator/.test(args)) found.push({
+			pid: Number(match[1]),
+			tool: "uiautomator"
+		});
+		else if (/androidx\.test|\binstrument\b/.test(args)) found.push({
+			pid: Number(match[1]),
+			tool: "instrumentation"
+		});
+	}
+	return found;
+}
+function latestDeviceLogAt(lines, target) {
+	return latestRecordAt(lines, (record) => {
+		if (record.src !== "device" || record.platform !== target.platform || !isDeviceRecord(record)) return false;
+		if (target.slot === "default") return record.slot === void 0;
+		return record.slot === target.slot && (record.deviceId === void 0 || record.deviceId === target.id);
+	});
+}
+function latestBundleRequestAt(lines, platform) {
+	return latestRecordAt(lines, (record) => record.event === "bundle_response_started" && record.platform === platform);
+}
+function latestRecordAt(lines, matches) {
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const record = parseObject(lines[i]);
+		if (record && typeof record.ts === "number" && matches(record)) return record.ts;
+	}
+	return null;
+}
+function isDeviceRecord(record) {
+	return !(typeof record.event === "string" && record.event.startsWith("collector_"));
+}
+function tailLines(path) {
+	let fd;
+	try {
+		fd = openSync(path, "r");
+		const size = fstatSync(fd).size;
+		const length = Math.min(size, LOG_TAIL_BYTES);
+		const buffer = Buffer.alloc(length);
+		readSync(fd, buffer, 0, length, size - length);
+		const lines = buffer.toString("utf8").split("\n");
+		return length < size ? lines.slice(1) : lines;
+	} catch {
+		return null;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+function envDir(name) {
+	const value = process.env[name]?.trim();
+	return value ? resolve(value) : null;
+}
+function agentDeviceDirs(home) {
+	const root = join(home, ".agent-device");
+	const leaseDirs = [envDir("AGENT_DEVICE_IOS_RUNNER_LEASE_DIR") ?? join(root, "apple-runner", "leases"), join(root, "ios-runner", "leases")];
+	return [{
+		kind: "claim",
+		dir: envDir("AGENT_DEVICE_CLAIMS_DIR") ?? join(root, "device-claims")
+	}, ...[...new Set(leaseDirs)].map((dir) => ({
+		kind: "runner-lease",
+		dir
+	}))];
+}
+function readAgentDeviceRecords(home) {
+	return agentDeviceDirs(home).flatMap(({ kind, dir }) => {
+		let names;
+		try {
+			names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+		} catch {
+			return [];
+		}
+		return names.map((name) => {
+			const path = join(dir, name);
+			let raw = null;
+			try {
+				raw = readFileSync(path, "utf8");
+			} catch {}
+			return parseAgentDeviceRecord(kind, path, raw);
+		});
+	});
+}
+function createActivityReader({ now = Date.now(), home = homedir(), startOf = process_identity_exports.inspectProcessStart, leaseFiles = listLeaseFiles } = {}) {
+	const exec = getExecutor();
+	let agentDevice;
+	let stimLeases;
+	let processes;
+	const logs = /* @__PURE__ */ new Map();
+	const log = (path) => {
+		if (!logs.has(path)) logs.set(path, tailLines(path));
+		return logs.get(path) ?? null;
+	};
+	return (target) => {
+		const evidence = {
+			drivers: [],
+			unknown: [],
+			recency: []
+		};
+		agentDevice ??= readAgentDeviceRecords(home).map((record) => ({
+			record,
+			liveness: agentDeviceLiveness(record, startOf)
+		}));
+		for (const { record, liveness } of agentDevice) {
+			if (record.deviceId !== null && record.deviceId !== target.id) continue;
+			const basis = record.kind === "claim" ? "agent-device-claim" : "agent-device-lease";
+			if (liveness === "live") evidence.drivers.push({
+				basis,
+				tool: "agent-device",
+				pid: record.owner?.pid ?? null,
+				since: record.createdAtMs !== null ? new Date(record.createdAtMs).toISOString() : null
+			});
+			else if (liveness === "unknown") evidence.unknown.push(basis);
+		}
+		try {
+			stimLeases ??= leaseFiles();
+		} catch {
+			stimLeases = [];
+			evidence.unknown.push("device-lock");
+		}
+		for (const entry of stimLeases) {
+			if (entry.platform !== target.platform || entry.id !== target.id) continue;
+			if (!entry.lease) evidence.unknown.push("device-lock");
+			else if (!leaseIsExpired(entry.lease, now)) evidence.drivers.push({
+				basis: "device-lock",
+				tool: "stim device lock",
+				pid: null,
+				since: entry.lease.grantedAt
+			});
+		}
+		if (processes === void 0) {
+			const output = exec.runFileQuiet("ps", [
+				"-axww",
+				"-o",
+				"pid=,lstart=,command="
+			], { timeoutMs: 5e3 });
+			processes = output === null ? null : parseProcessTable(output);
+		}
+		if (processes === null) evidence.unknown.push("driver-process");
+		for (const row of processes ?? []) {
+			const tool = driverTool(row.command, target.id);
+			if (tool) evidence.drivers.push({
+				basis: "driver-process",
+				tool,
+				pid: row.pid,
+				since: row.startedAt
+			});
+		}
+		if (target.platform === "android") {
+			const output = exec.runFileQuiet("adb", [
+				"-s",
+				target.id,
+				"shell",
+				"ps",
+				"-A",
+				"-o",
+				"PID,ARGS"
+			], { timeoutMs: 5e3 });
+			if (output === null) evidence.unknown.push("instrumentation");
+			for (const { pid, tool } of parseAndroidInstrumentation(output ?? "")) evidence.drivers.push({
+				basis: "instrumentation",
+				tool,
+				pid,
+				since: null
+			});
+		}
+		if (target.workspace) {
+			const dir = workspaceLogsDir(target.workspace);
+			const deviceAt = latestDeviceLogAt(log(join(dir, "device.ndjson")) ?? [], target);
+			if (deviceAt !== null) evidence.recency.push({
+				basis: "device-log",
+				at: deviceAt
+			});
+			const bundleAt = latestBundleRequestAt(log(join(dir, "metro.ndjson")) ?? [], target.platform);
+			if (bundleAt !== null) evidence.recency.push({
+				basis: "metro-bundle",
+				at: bundleAt
+			});
+			const usedAt = Date.parse(String(readWorkspaceState$1(target.workspace)?.lastUsedAt ?? ""));
+			if (Number.isFinite(usedAt)) evidence.recency.push({
+				basis: "workspace-use",
+				at: usedAt
+			});
+		}
+		return classifyActivity(evidence, now);
+	};
+}
+function workspaceActivity(workspace, now = Date.now()) {
+	const dir = workspaceLogsDir(workspace);
+	const state = readWorkspaceState$1(workspace);
+	const recency = [];
+	const deviceAt = latestRecordAt(tailLines(join(dir, "device.ndjson")) ?? [], (record) => record.src === "device" && isDeviceRecord(record));
+	if (deviceAt !== null) recency.push({
+		basis: "device-log",
+		at: deviceAt
+	});
+	const bundleAt = latestRecordAt(tailLines(join(dir, "metro.ndjson")) ?? [], (record) => record.event === "bundle_response_started");
+	if (bundleAt !== null) recency.push({
+		basis: "metro-bundle",
+		at: bundleAt
+	});
+	for (const [basis, value] of [["workspace-use", state?.lastUsedAt], ["supervisor-start", state?.supervisor?.startedAt]]) {
+		const at = Date.parse(String(value ?? ""));
+		if (Number.isFinite(at)) recency.push({
+			basis,
+			at
+		});
+	}
+	return classifyActivity({
+		drivers: [],
+		unknown: [],
+		recency
+	}, now);
+}
+//#endregion
+//#region src/engine/build-progress.ts
+const ACTIVE_BUILD_KEY = "activeBuild";
+const NO_BUILD_PROGRESS = {
+	step: () => {},
+	durations: () => ({}),
+	clear: () => {}
+};
+const COLD_PHASES = [
+	"prebuild",
+	"pods",
+	"compile"
+];
+const DEVICE_PHASES = ["install", "launch"];
+function startBuildProgress({ root, platform, slot, claim, now = Date.now, note = () => {} }) {
+	const startedAt = new Date(now()).toISOString();
+	const record = {
+		platform,
+		slot,
+		startedAt,
+		phase: "prepare",
+		phaseStartedAt: startedAt,
+		phases: [{
+			phase: "prepare",
+			startedAt
+		}],
+		claim: {
+			root: claim.root,
+			path: claim.path,
+			claimId: claim.claimId,
+			pid: claim.owner.pid
+		}
+	};
+	let warned = false;
+	const guard = (fn) => {
+		try {
+			fn();
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const write = () => guard(() => updateWorkspaceState(root, (state) => ({
+		...state,
+		[ACTIVE_BUILD_KEY]: record
+	})));
+	write();
+	return {
+		step(phase) {
+			if (phase === record.phase) return;
+			const at = new Date(now()).toISOString();
+			record.phase = phase;
+			record.phaseStartedAt = at;
+			record.phases.push({
+				phase,
+				startedAt: at
+			});
+			write();
+		},
+		durations() {
+			return phaseDurations(record.phases, now());
+		},
+		clear() {
+			guard(() => {
+				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
+			});
+		}
+	};
+}
+function phaseDurations(phases, now) {
+	const out = {};
+	phases.forEach(({ phase, startedAt }, index) => {
+		const start = Date.parse(startedAt);
+		const next = phases[index + 1];
+		const end = next ? Date.parse(next.startedAt) : now;
+		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
+		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
+	});
+	return out;
+}
+function parseActiveBuild(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const claim = record.claim;
+	if (record.platform !== "ios" && record.platform !== "android") return null;
+	if (!isPhase(record.phase)) return null;
+	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
+	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
+	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
+	return {
+		platform: record.platform,
+		slot: typeof record.slot === "string" ? record.slot : "default",
+		startedAt: record.startedAt,
+		phase: record.phase,
+		phaseStartedAt: record.phaseStartedAt,
+		phases,
+		claim: {
+			root: claim.root,
+			path: typeof claim.path === "string" ? claim.path : "",
+			claimId: claim.claimId,
+			pid: typeof claim.pid === "number" ? claim.pid : 0
+		}
+	};
+}
+function isPhase(value) {
+	return BUILD_PHASES.includes(value);
+}
+function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
+	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
+	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
+	return survey.unresolved.length ? "unknown" : "stale";
+}
+function liveOutcome(record) {
+	const seen = new Set(record.phases.map((entry) => entry.phase));
+	if (COLD_PHASES.some((phase) => seen.has(phase))) return "cold";
+	if (DEVICE_PHASES.some((phase) => seen.has(phase))) return "hit";
+	return null;
+}
+function median(values) {
+	if (!values.length) return null;
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function estimateBuild(history, platform, known, phase) {
+	const lists = history?.[platform];
+	const outcome = known ?? latestOutcome(lists);
+	const samples = outcome && lists?.[outcome] || [];
+	const phaseSamples = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
+	return {
+		outcome,
+		expectedMs: median(samples.map((sample) => sample.durationMs)),
+		expectedPhaseMs: median(phaseSamples),
+		basis: samples.length
+	};
+}
+function latestOutcome(lists) {
+	let latest = null;
+	for (const outcome of ["hit", "cold"]) {
+		const last = lists?.[outcome]?.at(-1);
+		const at = last ? Date.parse(last.at) : NaN;
+		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
+			outcome,
+			at
+		};
+	}
+	return latest?.outcome ?? null;
+}
+function buildReport(record, { state, history }) {
+	return {
+		platform: record.platform,
+		slot: record.slot,
+		state,
+		phase: record.phase,
+		startedAt: record.startedAt,
+		phaseStartedAt: record.phaseStartedAt,
+		...estimateBuild(history, record.platform, liveOutcome(record), record.phase)
+	};
+}
+function remainingText(remainingMs) {
+	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
+}
+function buildStatusLine(report, now) {
+	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
+	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
+	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
+	const head = `build: ${report.platform}${slot} ${report.phase}, ${formatElapsed(elapsedMs)} elapsed`;
+	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
+	if (report.expectedMs === null) return head;
+	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
+	const remainingMs = report.expectedMs - elapsedMs;
+	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
+}
+//#endregion
+export { buildStatusLine as a, createActivityReader as c, buildReport as i, idleForMs as l, NO_BUILD_PROGRESS as n, parseActiveBuild as o, activeBuildState as r, startBuildProgress as s, ACTIVE_BUILD_KEY as t, workspaceActivity as u };

package/dist/{cache-manifest-CYJi8-Hx.mjs → cache-manifest-Pubfp8wV.mjs}

@@ -1,8 +1,8 @@
-import { u as getConfigDir } from "./config-B7iyKWkL.mjs";
+import { u as getConfigDir } from "./config-BEq0Qw_a.mjs";
 import { existsSync } from "fs";
-import { homedir } from "os";
-import { join, resolve } from "path";
+import { isAbsolute, join, resolve } from "path";
 import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";
+import { homedir } from "os";
 //#region src/cache/cache-manifest.ts
 function manifestPath() {
 	return join(getConfigDir(), "caches.json");
@@ -53,7 +53,7 @@ function unregister(dir, path = manifestPath()) {
 	return removed;
 }
 function registeredCaches(path = manifestPath()) {
-	return readManifest(path).caches.filter((c) => c.dir && existsSync(c.dir)).map((c) => ({
+	return readManifest(path).caches.filter((c) => isAbsolute(c.dir) && existsSync(c.dir)).map((c) => ({
 		name: c.name,
 		dir: c.dir,
 		prune: c.prune === "atomic" ? "atomic" : "entries",

package/dist/cache-manifest.mjs

@@ -1,2 +1,2 @@
-import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-CYJi8-Hx.mjs";
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-Pubfp8wV.mjs";
 export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cli.mjs

@@ -1,27 +1,30 @@
 #!/usr/bin/env node
+import { _ as refuseRelativeStimPaths } from "./config-BEq0Qw_a.mjs";
 import { readFileSync } from "node:fs";
 import { Command } from "commander";
 //#region bin/cli.ts
 const commands = /* @__PURE__ */ new Map([
-	["doctor", () => import("./doctor-BMt156qe.mjs")],
-	["worktree", () => import("./worktree-CFLA-6MX.mjs")],
-	["start", () => import("./start-CmxtOKjU.mjs")],
-	["ports", () => import("./ports-BIbJaKNW.mjs")],
-	["stop", () => import("./stop-B1kOpYei.mjs")],
-	["ios", () => import("./ios-BP04pY5f.mjs")],
-	["android", () => import("./android-BRgBYzU0.mjs")],
-	["reload", () => import("./reload-BdypPbjM.mjs")],
-	["device", () => import("./device-RdujjHLB.mjs")],
-	["logs", () => import("./logs-CakdBTtm.mjs")],
-	["status", () => import("./status-DdkLki47.mjs")],
-	["stats", () => import("./stats-CLg5RuDS.mjs")],
-	["gc", () => import("./gc-v2YcoJvm.mjs")],
-	["guide", () => import("./guide-BTAlD1_y.mjs")]
+	["doctor", () => import("./doctor-B-inAJmt.mjs")],
+	["worktree", () => import("./worktree-4aZg2NnI.mjs")],
+	["start", () => import("./start-VoFsPSes.mjs")],
+	["ports", () => import("./ports-CLSSFOuz.mjs")],
+	["stop", () => import("./stop-ZvOeTmKb.mjs")],
+	["ios", () => import("./ios-Dd-hYJBh.mjs")],
+	["android", () => import("./android-DBkeHwpm.mjs")],
+	["reload", () => import("./reload-DoETJ3rl.mjs")],
+	["device", () => import("./device-DhTZe7L4.mjs")],
+	["logs", () => import("./logs-MARIy6m9.mjs")],
+	["settings", () => import("./settings-EWYNwe72.mjs")],
+	["status", () => import("./status-DLCD-o3s.mjs")],
+	["stats", () => import("./stats-DBYJ5bxL.mjs")],
+	["gc", () => import("./gc-ChPFZMRC.mjs")],
+	["guide", () => import("./guide-DwmaD_Wa.mjs")]
 ]);
 const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 const program = new Command();
 program.name("stim").description("Isolated React Native dev environments per project/worktree").version(pkg.version);
 try {
+	refuseRelativeStimPaths();
 	const first = process.argv[2];
 	const loadCommand = commands.get((first === "help" ? process.argv[3] : first) ?? "");
 	if (loadCommand) (await loadCommand()).default(program, pkg.version);
@@ -31,11 +34,11 @@ try {
 	}
 	await program.parseAsync();
 } catch (err) {
-	if (err?.code === "STIM_CONFIG_CORRUPT") {
-		console.error(err.message);
-		process.exit(1);
-	}
-	throw err;
+	const code = err?.code;
+	const message = err instanceof Error ? err.message : String(err);
+	if (typeof code === "string" && code.startsWith("STIM_")) console.error(`${code}: ${message}`);
+	else console.error(`Unexpected error: ${message.replace(/\.$/, "")}. Report it at ${pkg.bugs.url}`);
+	process.exit(1);
 }
 //#endregion
 export {};

package/dist/collector-run.d.mts

@@ -1,4 +1,4 @@
-import { t as NdjsonWriter } from "./ndjson-DvHSsNU9.mjs";
+import { t as NdjsonWriter } from "./ndjson-Du3j0AQ9.mjs";
 import { ChildProcess, SpawnOptions } from "child_process";
 import { ChildProcess as ChildProcess$1 } from "node:child_process";
 //#region src/exec.d.ts
@@ -8,10 +8,16 @@ interface ExecOptions {
   cwd?: string;
   env?: Record<string, string>;
   omitEnv?: readonly string[];
+  /** Text written to the child's stdin; `runFile` only. */
+  input?: string;
+  /** `runFile` only: return stdout as written, without trimming surrounding whitespace. */
+  untrimmed?: boolean;
 }
 interface Executor {
   run(cmd: string, opts?: ExecOptions): string;
   runFile(file: string, args?: string[], opts?: ExecOptions): string;
+  /** `runFile` without blocking the event loop; rejects where `runFile` throws. */
+  runFileAsync(file: string, args?: string[], opts?: ExecOptions): Promise<string>;
   runQuiet(cmd: string, opts?: ExecOptions): string | null;
   runFileQuiet(file: string, args?: string[], opts?: ExecOptions): string | null;
   spawn(cmd: string, args?: readonly string[], opts?: SpawnOptions): ChildProcess;

package/dist/collector-run.mjs

@@ -1,12 +1,13 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { B as validateDeviceSlot, F as deviceSlotKey, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { _ as workspaceLogsDir } from "./workspace-state-BT5E3SA2.mjs";
-import { t as createLineReader } from "./process-output-Dl5uKE03.mjs";
-import { i as startIosDeviceConsole, r as parseDeviceConsoleLine } from "./ios-device-CFXA46ez.mjs";
-import { a as unregisterCollector, i as registerCollector, r as readCollectors, t as collectorProcessTitle } from "./ownership-Cp52QAK1.mjs";
-import { a as watchAppPid, i as waitForAppPid, n as parseLogcatLine, r as startAndroidLogcat, t as androidClockOffset } from "./android-DeYdjjBP.mjs";
+import { D as process_identity_exports, R as deviceSlotKey, W as validateDeviceSlot } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { j as workspaceLogsDir } from "./metro-BWLOJ_Wr.mjs";
+import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { a as startIosDeviceConsole, i as parseDeviceConsoleLine } from "./ios-device-BiOsSVzd.mjs";
+import { a as unregisterCollector, i as registerCollector, r as readCollectors, t as collectorProcessTitle } from "./ownership-D2xbLVoz.mjs";
+import { a as watchAppPid, i as waitForAppPid, n as parseLogcatLine, r as startAndroidLogcat, t as androidClockOffset } from "./android-DPov-fv2.mjs";
 import { existsSync } from "node:fs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/collector/ios.ts
@@ -299,7 +300,7 @@ async function runCollector({ slot = "default", platform, root, udid = null, app
 		slot,
 		deviceId: udid ?? serial
 	};
-	const writer = createNdjsonWriter(join(workspaceLogsDir(root), "device.ndjson"));
+	const writer = createNdjsonWriter(join(workspaceLogsDir(root), "device.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
 	const startedAt = new Date(now()).toISOString();
 	const processToken = (0, process_identity_exports.captureProcessToken)(process.pid);
 	if (!processToken) {