stim 1.8.0 → 1.10.0

package/dist/status-DLCD-o3s.mjs

@@ -0,0 +1,764 @@
+import { F as volumeRootFor, H as projectDeviceSlots, g as loadConfig$1, u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { a as parseNdjsonLine } from "./ndjson-CDY9IkVC.mjs";
+import { A as workspaceLogErrorIndex, a as processCwd, j as workspaceLogsDir, l as isMetroRunning, m as readWorkspaceState$1, n as listeningPids, o as processCwds, r as listeningPidsByPort, s as resolveProjectMetro } from "./metro-BWLOJ_Wr.mjs";
+import { c as gitCommonDirOnDisk, p as linkedWorktreesOnDisk, s as gitCommonDir, y as repoRoot } from "./worktree-BlizKDpZ.mjs";
+import { l as projectShortcut, o as findProjectRoot } from "./project-BXZzOABt.mjs";
+import { l as readRemoteSession } from "./state-WGdIbi_d.mjs";
+import { i as listLeaseFiles } from "./device-lease-CbEaIk7b.mjs";
+import { a as buildStatusLine, c as createActivityReader, i as buildReport, o as parseActiveBuild, r as activeBuildState, t as ACTIVE_BUILD_KEY } from "./build-progress-BXx-ZBe4.mjs";
+import { N as ownedAvdSerialResolver, c as androidToolPath } from "./android-787HhP5w.mjs";
+import { b as readParked, h as POOL_SETTING_REMEDY, t as resolveSupervisorTarget, y as parkedMaxSetting } from "./ownership-DZjdx8Gq.mjs";
+import { _ as parseSimctlList, u as listAllIosSimsAsync } from "./ios-B2Fpqvlb.mjs";
+import { m as readEasSessionLedger$1, p as easMachineStateRoot$1 } from "./device-remote-Dy1jGj3U.mjs";
+import { a as diskLine, c as parseDfFree, d as remoteDeviceState, f as tightVolumes, i as deviceLeaseStates, l as poolLine, n as capacity, o as environmentState, p as unprovisionedWorktrees, r as deviceLeaseLines, t as activityLabel, u as remoteDeviceLine } from "./status-Dr4fRkym.mjs";
+import { a as statsProjectKey, r as readStats } from "./stats-BAgJaLA4.mjs";
+import { i as readSupervisorState } from "./stop-Dj4pfmyv.mjs";
+import { readdirSync, watch } from "node:fs";
+import { closeSync as closeSync$1, existsSync as existsSync$1, fstatSync as fstatSync$1, openSync as openSync$1, readFileSync as readFileSync$1, readSync as readSync$1, renameSync as renameSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
+import { basename, dirname, join } from "path";
+import { rotatedLogPath } from "@stim-cli/core";
+import { ERROR_SOURCES, logFiles, queryLogs, readIdleStop, recordMatches } from "@stim-cli/core/state";
+import { join as join$1 } from "node:path";
+import { totalmem } from "os";
+import chalk from "chalk";
+//#region src/status-watch.ts
+const WATCH_FALLBACK_MS = 3e4;
+const WATCH_SIMCTL_INTERVAL_MS = 2e3;
+const ADB_RESTART_MIN_MS = 1e3;
+const ADB_RESTART_MAX_MS = 6e4;
+const SIMCTL_TIMEOUT_MS = 1e4;
+/**
+* Coalesces change signals into refreshes: a burst of triggers runs `run` once
+* after `debounceMs` of quiet, at most one run is in flight, and a trigger that
+* arrives during a run causes exactly one more run after it.
+*/
+function createRefreshScheduler({ debounceMs, run }) {
+	let timer = null;
+	let running = false;
+	let pending = false;
+	let stopped = false;
+	const fire = async () => {
+		timer = null;
+		running = true;
+		try {
+			await run();
+		} finally {
+			running = false;
+			if (pending) {
+				pending = false;
+				trigger();
+			}
+		}
+	};
+	function trigger(delayMs = debounceMs) {
+		if (stopped) return;
+		if (running) {
+			pending = true;
+			return;
+		}
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => void fire(), delayMs);
+	}
+	return {
+		trigger,
+		stop() {
+			stopped = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+		}
+	};
+}
+/**
+* Whether a change to `name` in a watched `$STIM_HOME` directory can change
+* the status payload. A null name means the platform did not report one.
+*/
+function changeAffectsStatus(dir, name) {
+	if (name === null) return true;
+	if (name.includes(".lock")) return false;
+	switch (dir) {
+		case "home": return name.startsWith("config.json") || name === "workspaces" || name === "device-locks";
+		case "workspace": return name.startsWith("state.json") || name === "logs";
+		case "eas": return name.startsWith("sessions.json");
+		default: return true;
+	}
+}
+/** A stable summary of every simulator's state, or null when the listing is unreadable. */
+function simulatorSignature(simctlJson) {
+	try {
+		return parseSimctlList(simctlJson, { includeUnavailable: true }).map((sim) => `${sim.udid}:${sim.state}`).toSorted().join(",");
+	} catch {
+		return null;
+	}
+}
+/**
+* Calls `onChange` when anything `stim status` reports may have changed:
+* `$STIM_HOME` files, adb device arrivals and departures, and simulator
+* state. simctl has no push API reachable from Node, so it is polled.
+*/
+function watchStatusSources({ home, onChange, platform = process.platform, simctlIntervalMs = WATCH_SIMCTL_INTERVAL_MS }) {
+	let stopped = false;
+	const watchers = /* @__PURE__ */ new Map();
+	const desiredDirs = () => {
+		const dirs = /* @__PURE__ */ new Map([
+			[home, "home"],
+			[join$1(home, "workspaces"), "workspaces"],
+			[join$1(home, "device-locks"), "leases"],
+			[easMachineStateRoot$1(), "eas"]
+		]);
+		let names = [];
+		try {
+			names = readdirSync(join$1(home, "workspaces"));
+		} catch {}
+		for (const name of names) {
+			const dir = join$1(home, "workspaces", name);
+			dirs.set(dir, "workspace");
+			dirs.set(join$1(dir, "logs"), "logs");
+		}
+		return dirs;
+	};
+	const reconcile = () => {
+		if (stopped) return;
+		const desired = desiredDirs();
+		for (const [dir, watcher] of watchers) if (!desired.has(dir)) {
+			watcher.close();
+			watchers.delete(dir);
+		}
+		for (const [dir, kind] of desired) {
+			if (watchers.has(dir)) continue;
+			try {
+				const watcher = watch(dir, (_event, name) => {
+					if (!changeAffectsStatus(kind, name === null ? null : String(name))) return;
+					if (kind === "home" || kind === "workspaces" || kind === "workspace") reconcile();
+					onChange();
+				});
+				watcher.on("error", () => {
+					watcher.close();
+					watchers.delete(dir);
+				});
+				watchers.set(dir, watcher);
+			} catch {}
+		}
+	};
+	const adb = trackAdbDevices(onChange);
+	let simctl = null;
+	let simTimer = null;
+	if (platform === "darwin") {
+		let last = null;
+		const check = () => {
+			if (simctl || stopped) return;
+			let out = "";
+			const child = getExecutor().spawn("xcrun", [
+				"simctl",
+				"list",
+				"devices",
+				"--json"
+			], {
+				stdio: [
+					"ignore",
+					"pipe",
+					"ignore"
+				],
+				timeout: SIMCTL_TIMEOUT_MS,
+				killSignal: "SIGKILL"
+			});
+			simctl = child;
+			child.stdout?.on("data", (chunk) => out += chunk.toString());
+			child.on("error", () => {
+				simctl = null;
+			});
+			child.on("close", () => {
+				simctl = null;
+				const signature = simulatorSignature(out);
+				if (signature === null || stopped) return;
+				if (last !== null && signature !== last) onChange();
+				last = signature;
+			});
+		};
+		check();
+		simTimer = setInterval(check, simctlIntervalMs);
+	}
+	reconcile();
+	return {
+		reconcile,
+		stop() {
+			stopped = true;
+			for (const watcher of watchers.values()) watcher.close();
+			watchers.clear();
+			if (simTimer) clearInterval(simTimer);
+			simctl?.kill("SIGKILL");
+			adb.stop();
+		}
+	};
+}
+/**
+* Runs `adb track-devices` and calls `onChange` on every device list it
+* reports. adb exits when its server restarts, so the tracker restarts with a
+* doubling delay that resets once a run lasts a minute.
+*/
+function trackAdbDevices(onChange) {
+	const exec = getExecutor();
+	const resolved = androidToolPath("adb");
+	const adb = resolved === "adb" ? exec.findExecutable("adb") : resolved;
+	if (!adb) return { stop() {} };
+	let child = null;
+	let restart = null;
+	let delay = ADB_RESTART_MIN_MS;
+	let stopped = false;
+	const start = () => {
+		restart = null;
+		if (stopped) return;
+		const startedAt = Date.now();
+		const current = exec.spawn(adb, ["track-devices"], { stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		] });
+		child = current;
+		current.stdout?.on("data", () => onChange());
+		current.on("error", () => {});
+		current.on("close", () => {
+			if (child === current) child = null;
+			if (stopped) return;
+			if (Date.now() - startedAt >= ADB_RESTART_MAX_MS) delay = ADB_RESTART_MIN_MS;
+			restart = setTimeout(start, delay);
+			delay = Math.min(delay * 2, ADB_RESTART_MAX_MS);
+		});
+	};
+	start();
+	return { stop() {
+		stopped = true;
+		if (restart) clearTimeout(restart);
+		child?.kill("SIGTERM");
+	} };
+}
+//#endregion
+//#region src/diagnostics/error-index.ts
+const INDEX_VERSION = 1;
+const HEAD_BYTES = 1024;
+const TAIL_BYTES = 256;
+const CHUNK_BYTES = 4194304;
+const NEWLINE = 10;
+const CANDIDATE_PATTERNS = [
+	"\"level\":\"error\"",
+	"\"level\":\"fatal\"",
+	"\"marker\":true"
+].map((p) => Buffer.from(p));
+const ERROR_CRITERIA = {
+	errorsOnly: true,
+	sources: ERROR_SOURCES,
+	includeNativeCrashes: true
+};
+/**
+* The number of records `queryLogs({ dir, errorsOnly: true })` returns, without parsing every
+* line on every call. `indexFile` keeps, per log file generation, the markers and error records
+* already read and the byte offset they were read through; a later call reads only what was
+* appended since. The index is a cache: losing it or a concurrent writer only costs a rescan.
+*/
+function countErrorsSinceMarker(dir, indexFile) {
+	const previous = readIndex(indexFile);
+	const files = {};
+	let changed = false;
+	for (const name of logFiles(dir)) {
+		const current = join(dir, name);
+		for (const path of [rotatedLogPath(current), current]) {
+			const result = summarize(path, previous.files);
+			if (!result) continue;
+			files[result.key] = result.summary;
+			if (result.changed) changed = true;
+		}
+	}
+	if (changed || Object.keys(files).length !== Object.keys(previous.files).length) writeIndex(indexFile, {
+		version: INDEX_VERSION,
+		files
+	});
+	const records = [];
+	for (const summary of Object.values(files)) records.push(...Object.values(summary.markers), ...summary.errors);
+	return queryLogs({
+		records,
+		errorsOnly: true
+	}).length;
+}
+function summarize(path, known) {
+	let fd;
+	try {
+		fd = openSync$1(path, "r");
+	} catch {
+		return null;
+	}
+	try {
+		const { dev, ino, size } = fstatSync$1(fd);
+		const key = `${dev}:${ino}`;
+		const cached = known[key];
+		const base = cached && stillExtends(fd, cached, size) ? cached : null;
+		const start = base ?? {
+			offset: 0,
+			head: "",
+			tail: "",
+			markers: {},
+			errors: []
+		};
+		if (size <= start.offset) return {
+			key,
+			summary: start,
+			changed: !base
+		};
+		const summary = readFrom(fd, start, size);
+		return {
+			key,
+			summary,
+			changed: !base || summary.offset !== start.offset
+		};
+	} catch {
+		return null;
+	} finally {
+		closeSync$1(fd);
+	}
+}
+function stillExtends(fd, summary, size) {
+	if (size < summary.offset) return false;
+	const head = Buffer.from(summary.head, "base64");
+	const tail = Buffer.from(summary.tail, "base64");
+	return readAt(fd, 0, head.length).equals(head) && readAt(fd, summary.offset - tail.length, tail.length).equals(tail);
+}
+function readAt(fd, position, length) {
+	const buf = Buffer.alloc(length);
+	const read = length > 0 ? readSync$1(fd, buf, 0, length, position) : 0;
+	return buf.subarray(0, read);
+}
+function readFrom(fd, start, size) {
+	const markers = { ...start.markers };
+	const errors = [...start.errors];
+	let offset = start.offset;
+	let chunk = CHUNK_BYTES;
+	while (offset < size) {
+		const buf = readAt(fd, offset, Math.min(chunk, size - offset));
+		if (buf.length === 0) break;
+		const end = buf.lastIndexOf(NEWLINE);
+		if (end === -1) {
+			if (offset + buf.length >= size) break;
+			chunk *= 2;
+			continue;
+		}
+		for (const record of candidateRecords(buf.subarray(0, end + 1))) collect(record, markers, errors);
+		offset += end + 1;
+	}
+	if (offset === start.offset) return start;
+	return {
+		offset,
+		head: start.offset >= HEAD_BYTES ? start.head : readAt(fd, 0, Math.min(HEAD_BYTES, offset)).toString("base64"),
+		tail: readAt(fd, Math.max(0, offset - TAIL_BYTES), Math.min(TAIL_BYTES, offset)).toString("base64"),
+		markers,
+		errors
+	};
+}
+function candidateRecords(region) {
+	const lineStarts = /* @__PURE__ */ new Set();
+	for (const pattern of CANDIDATE_PATTERNS) for (let hit = region.indexOf(pattern); hit !== -1; hit = region.indexOf(pattern, hit + pattern.length)) lineStarts.add(region.lastIndexOf(NEWLINE, hit) + 1);
+	const records = [];
+	for (const lineStart of [...lineStarts].toSorted((a, b) => a - b)) {
+		const record = parseNdjsonLine(region.toString("utf-8", lineStart, region.indexOf(NEWLINE, lineStart)));
+		if (record) records.push(record);
+	}
+	return records;
+}
+function collect(record, markers, errors) {
+	const ts = typeof record.ts === "number" && Number.isFinite(record.ts) ? record.ts : null;
+	if (record.marker === true && ts !== null) {
+		const metro = record.src === "metro";
+		const slot = record.slot ?? "default";
+		const key = metro ? "metro" : JSON.stringify(["launch", slot]);
+		if ((markers[key]?.ts ?? -Infinity) < ts) markers[key] = metro ? {
+			src: "metro",
+			marker: true,
+			ts
+		} : {
+			marker: true,
+			ts,
+			slot
+		};
+	}
+	if (recordMatches(record, ERROR_CRITERIA)) errors.push({
+		src: record.src,
+		level: record.level,
+		event: record.event,
+		ts: ts ?? void 0,
+		slot: record.slot
+	});
+}
+function readIndex(file) {
+	try {
+		const parsed = JSON.parse(readFileSync$1(file, "utf-8"));
+		if (parsed?.version === INDEX_VERSION && parsed.files && typeof parsed.files === "object") return parsed;
+	} catch {}
+	return {
+		version: INDEX_VERSION,
+		files: {}
+	};
+}
+function writeIndex(file, index) {
+	const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		writeFileSync$1(tmp, JSON.stringify(index));
+		renameSync$1(tmp, file);
+	} catch {
+		rmSync$1(tmp, { force: true });
+	}
+}
+//#endregion
+//#region src/commands/status.ts
+function formatGb(mb) {
+	return `${(mb / 1024).toFixed(1)} GB`;
+}
+function statusCommand(program) {
+	program.command("status").description("Show every environment on this machine: devices, ports, what is actually running, and anything stuck.").option("--json", "print the state as JSON").option("--watch", "keep running and print the state again each time it changes").action(async (opts) => {
+		if (opts.watch) return watchStatus(Boolean(opts.json));
+		for (const line of await statusLines(Boolean(opts.json))) console.log(line);
+	});
+}
+async function statusLines(json) {
+	const out = [];
+	const cfg = loadConfig$1();
+	const projects = Object.entries(cfg?.projects || {});
+	const cwdRoot = findProjectRoot(process.cwd());
+	const simsRead = listAllIosSimsAsync();
+	simsRead.catch(() => {});
+	const ports = await portLookup(projects.flatMap(([, proj]) => proj.metroPort ? [proj.metroPort] : []));
+	const processes = Promise.all(projects.map(async ([path, proj]) => {
+		const metro = proj.metroPort ? await resolveOnPort(proj.metroPort, path, ports) : null;
+		return {
+			metro,
+			supervisor: await supervisorFacts(path, proj, metro, ports)
+		};
+	}));
+	processes.catch(() => {});
+	const androidRuntimeOf = androidRuntimeReader();
+	const devices = projects.map(([, proj]) => ({
+		androidRuntimes: Object.fromEntries(projectDeviceSlots(proj).slice(1).map(({ slot, platforms }) => [slot, platforms.android?.owned && platforms.android.avdName ? androidRuntimeOf(platforms.android.avdName) : null])),
+		androidRuntime: proj.platforms?.android?.owned && proj.platforms.android.avdName ? androidRuntimeOf(proj.platforms.android.avdName) : null
+	}));
+	const logs = projects.map(([path]) => logFacts(path));
+	const simsByUdid = {};
+	let simsAvailable = true;
+	let simctlError = null;
+	try {
+		for (const sim of await simsRead) simsByUdid[sim.udid] = sim;
+	} catch (e) {
+		simsAvailable = false;
+		simctlError = String(e?.message || e).split("\n")[0] ?? "";
+	}
+	const running = await processes;
+	const worktrees = linkedWorktrees([process.cwd(), ...projects.map(([path]) => path)]);
+	const history = readStats().record?.history;
+	const states = [];
+	const labelOnlyRoots = [];
+	const easLedger = readEasSessionLedger$1();
+	for (const [i, [path, proj]] of projects.entries()) {
+		const { metro, supervisor } = running[i];
+		states.push(environmentState({
+			...proj,
+			__path: path
+		}, {
+			simsByUdid,
+			metro,
+			worktrees,
+			simsAvailable,
+			...devices[i],
+			supervisor,
+			logs: logs[i],
+			remote: remoteDeviceState(readRemoteSession(path), easLedger, path),
+			idleStop: readIdleStop(readWorkspaceState$1(path))
+		}));
+		const state = states[states.length - 1];
+		if (state) state.build = workspaceBuild(path, history);
+		labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android));
+	}
+	const readActivity = createActivityReader();
+	for (const state of states) for (const device of [{
+		slot: "default",
+		ios: state.ios,
+		android: state.android
+	}, ...state.slots ?? []]) {
+		const base = {
+			slot: device.slot,
+			workspace: state.path
+		};
+		if (device.ios?.state === "Booted") device.ios.activity = readActivity({
+			...base,
+			platform: "ios",
+			id: device.ios.udid
+		});
+		if (device.android && !device.android.physical && device.android.serial) device.android.activity = readActivity({
+			...base,
+			platform: "android",
+			id: device.android.serial
+		});
+	}
+	const leaseNow = Date.now();
+	const leases = deviceLeaseStates(listLeaseFiles(), {
+		root: cwdRoot,
+		now: leaseNow
+	});
+	const totalMemoryMb = Math.round(totalmem() / 1048576);
+	const cap = capacity(states, totalMemoryMb);
+	const orphanWorktrees = unprovisionedWorktrees(worktrees, projects.map(([p]) => p));
+	const pools = ["ios", "android"].map((platform) => {
+		const { max, error } = parkedMaxSetting(platform);
+		return {
+			error,
+			line: poolLine({
+				platform,
+				parked: readParked(platform).length,
+				max
+			})
+		};
+	});
+	if (json) {
+		out.push(JSON.stringify({
+			environments: states.map((state, i) => labelOnlyRoots[i] ? {
+				...state,
+				labelOnly: true
+			} : state),
+			capacity: cap,
+			deviceLeases: leases,
+			unprovisionedWorktrees: orphanWorktrees,
+			simctlAvailable: simsAvailable
+		}));
+		return out;
+	}
+	if (projects.length === 0 && orphanWorktrees.length === 0) {
+		out.push(chalk.dim("No projects registered."));
+		for (const pool of pools) {
+			if (pool.error) out.push(chalk.yellow(`${pool.error} ${POOL_SETTING_REMEDY}`));
+			if (pool.line) out.push(chalk.dim(pool.line));
+		}
+		for (const line of deviceLeaseLines(leases, leaseNow)) out.push(line);
+		return out;
+	}
+	if (!simsAvailable) out.push(chalk.yellow(`simctl could not be read (${simctlError}), so no iOS sim below could be checked.`));
+	for (const [i, [path, proj]] of projects.entries()) {
+		const state = states[i];
+		if (!state) continue;
+		const shortcut = projectShortcut(path, proj);
+		const marker = path === cwdRoot ? chalk.bold.cyan(`* ${shortcut}`) : shortcut;
+		const idle = state.live ? "" : chalk.dim(" [idle]");
+		out.push(`\n${marker}${idle} ${chalk.dim(`(${path})`)}`);
+		out.push(labelOnlyRoots[i] ? chalk.dim("  worktree root (holds the label; the app registers its own entry)") : chalk.dim(`  app: ${proj.bundleId ?? "?"} (${proj.isExpo ? "expo" : "bare"})`));
+		if (state.metro) {
+			const label = state.metro.running ? chalk.green(`running (pid ${state.metro.pid})`) : state.metro.idleStop ? chalk.dim(`stopped (idle) after ${state.metro.idleStop.idleMinutes}m; \`stim start\`, \`ios\` or \`android\` restarts it`) : chalk.dim("not running");
+			out.push(`  metro: port ${state.metro.port} ${label}`);
+		}
+		if (state.supervisor) {
+			const health = state.supervisor.healthy ? chalk.green("healthy") : chalk.yellow("not answering");
+			const mode = state.supervisor.mode ? chalk.dim(` (${state.supervisor.mode})`) : "";
+			out.push(`  supervisor: pid ${state.supervisor.pid}${mode} ${health}`);
+		}
+		if (state.build) {
+			const line = `  ${buildStatusLine(state.build, Date.now())}`;
+			out.push(state.build.state === "running" ? line : chalk.yellow(line));
+		}
+		if (state.logs) {
+			const n = state.logs.errorsSinceMarker;
+			const errs = n > 0 ? chalk.yellow(` (${n} error${n === 1 ? "" : "s"} since the last marker)`) : "";
+			out.push(chalk.dim(`  logs: ${state.logs.dir}`) + errs);
+		}
+		for (const deviceState of [{
+			slot: "default",
+			ios: state.ios,
+			android: state.android
+		}, ...state.slots ?? []]) {
+			const slotLabel = deviceState.slot === "default" ? "" : ` [${deviceState.slot}]`;
+			if (deviceState.ios) {
+				const booted = deviceState.ios.state === "Booted" ? chalk.green("booted") : chalk.dim(deviceState.ios.state.toLowerCase());
+				const owned = deviceState.ios.owned ? chalk.dim(" (owned)") : "";
+				out.push(`  ios${slotLabel}: ${chalk.cyan(deviceState.ios.name ?? deviceState.ios.udid)} ${booted}${owned}${activitySuffix(deviceState.ios.activity)}`);
+			}
+			if (deviceState.android) {
+				const kind = deviceState.android.physical ? chalk.dim("(physical)") : chalk.dim("(emulator)");
+				const observed = deviceState.android.state ? ` ${deviceState.android.state}${deviceState.android.serial ? ` (${deviceState.android.serial})` : ""}` : "";
+				out.push(`  android${slotLabel}: ${chalk.cyan(deviceState.android.name)} ${kind}${observed}${deviceState.android.owned ? chalk.dim(" (owned)") : ""}${activitySuffix(deviceState.android.activity)}`);
+			}
+		}
+		for (const remote of state.remoteDevices ?? []) out.push(`  ${remoteDeviceLine(remote)}`);
+		for (const w of state.warnings) out.push(chalk.yellow(`  ! ${w}`));
+	}
+	for (const pool of pools) {
+		if (pool.error) out.push(chalk.yellow(`\n${pool.error} ${POOL_SETTING_REMEDY}`));
+		if (pool.line) out.push(chalk.dim(`\n${pool.line}`));
+	}
+	const leaseLines = deviceLeaseLines(leases, leaseNow);
+	if (leaseLines.length) {
+		out.push("");
+		for (const line of leaseLines) out.push(line);
+	}
+	if (orphanWorktrees.length) {
+		out.push(chalk.dim(`\nWorktrees with no environment (${orphanWorktrees.length}):`));
+		for (const w of orphanWorktrees) out.push(chalk.dim(`  ${w.path}${w.branch ? ` [${w.branch}]` : ""}`));
+	}
+	out.push(chalk.dim(`\n${cap.liveCount} live environment(s), roughly ${formatGb(cap.committedMb)} of ${formatGb(cap.totalMemoryMb)} committed.`));
+	const volumes = readVolumes(cwdRoot || process.cwd());
+	const line = diskLine(volumes);
+	if (line) {
+		const tight = tightVolumes(volumes);
+		if (tight.length) {
+			const which = tight.map((v) => v.volume).join(" and ");
+			out.push(chalk.yellow(`${line} A single iOS build can exhaust ${which} -- run \`stim gc\` before starting another environment.`));
+		} else out.push(chalk.dim(line));
+	}
+	if (cap.overCapacity) out.push(chalk.yellow("Over comfortable capacity. A machine that swaps is slower than one working in sequence -- release one before starting another."));
+	return out;
+}
+async function watchStatus(json) {
+	let last = null;
+	let sources = null;
+	const scheduler = createRefreshScheduler({
+		debounceMs: 250,
+		run: async () => {
+			let text;
+			try {
+				text = (await statusLines(json)).join("\n");
+			} catch (error) {
+				console.error(chalk.red(String(error?.message || error)));
+				return;
+			} finally {
+				sources?.reconcile();
+			}
+			if (text === last) return;
+			last = text;
+			process.stdout.write(`${!json && process.stdout.isTTY ? "\x1B[2J\x1B[H" : ""}${text}\n`);
+		}
+	});
+	const fallback = setInterval(() => scheduler.trigger(), WATCH_FALLBACK_MS);
+	const finish = () => {
+		clearInterval(fallback);
+		scheduler.stop();
+		sources?.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", finish);
+	process.on("SIGTERM", finish);
+	process.stdout.on("error", finish);
+	sources = watchStatusSources({
+		home: getConfigDir(),
+		onChange: () => scheduler.trigger()
+	});
+	scheduler.trigger(0);
+	await new Promise(() => {});
+}
+function activitySuffix(activity) {
+	const label = activityLabel(activity, Date.now());
+	return label ? ` -- ${activity?.state === "driven" ? chalk.magenta(label) : chalk.dim(label)}` : "";
+}
+function linkedWorktrees(paths) {
+	return [...new Set(paths.flatMap((path) => gitCommonDirOnDisk(path) ?? []))].flatMap((common) => {
+		const repository = basename(common) === ".git" ? dirname(common) : common;
+		return linkedWorktreesOnDisk(common).map((entry) => Object.assign(entry, { repository }));
+	});
+}
+function workspaceBuild(path, history) {
+	const record = parseActiveBuild(readWorkspaceState$1(path)?.[ACTIVE_BUILD_KEY]);
+	if (!record) return null;
+	const projectKey = statsProjectKey({
+		root: path,
+		commonDir: gitCommonDir(path),
+		repoRoot: repoRoot(path)
+	});
+	return buildReport(record, {
+		state: activeBuildState(record.claim),
+		history: history?.[projectKey]
+	});
+}
+function androidRuntimeReader() {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return (avdName) => readAndroidRuntime(() => resolve(avdName));
+}
+function readAndroidRuntime(resolveSerial) {
+	try {
+		const resolved = resolveSerial();
+		return {
+			serial: resolved.serial ?? null,
+			state: resolved.serial ? "detected" : resolved.missing ? "missing" : resolved.notRunning ? "not-detected" : "unknown"
+		};
+	} catch (error) {
+		return {
+			serial: null,
+			state: "unknown",
+			error: String(error?.message || error).split("\n")[0]
+		};
+	}
+}
+function readVolumes(projectPath) {
+	const roots = [.../* @__PURE__ */ new Set([
+		"/",
+		volumeRootFor(getConfigDir()),
+		volumeRootFor(projectPath)
+	])];
+	const volumes = [];
+	for (const volume of roots) {
+		const quoted = `'${volume.replace(/'/g, "'\\''")}'`;
+		const disk = parseDfFree(getExecutor().runQuiet(`df -k ${quoted}`, { timeoutMs: 5e3 }));
+		if (disk) volumes.push({
+			volume,
+			disk
+		});
+	}
+	return volumes;
+}
+async function portLookup(metroPorts) {
+	const ports = [...new Set(metroPorts)];
+	const answering = new Map(await Promise.all(ports.map(async (port) => [port, await isMetroRunning(port)])));
+	const listeners = listeningPidsByPort(ports.filter((port) => answering.get(port)));
+	const cwds = listeners.then((byPort) => processCwds([...byPort.values()].flatMap((pids) => pids.slice(0, 1))));
+	return {
+		answering,
+		pidsOf: async (port) => (await listeners).get(port) ?? listeningPids(port),
+		cwdOf: async (pid) => {
+			const known = await cwds;
+			return known.has(pid) ? known.get(pid) ?? null : processCwd(pid);
+		}
+	};
+}
+async function resolveOnPort(port, path, lookup) {
+	return lookup.answering.get(port) ?? await isMetroRunning(port) ? resolveProjectMetro(port, path, lookup) : { missing: true };
+}
+async function supervisorFacts(path, proj, metroResolution, lookup) {
+	const state = readSupervisorState(path);
+	const record = proj?.supervisor ?? null;
+	const pid = state?.pid ?? record?.pid ?? null;
+	if (!pid) return null;
+	const port = state?.port ?? record?.port ?? null;
+	const alive = resolveSupervisorTarget({
+		state,
+		record,
+		reservedPort: proj?.metroPort
+	}).status === "ours";
+	let healthy = false;
+	if (alive && port) {
+		const resolution = port === proj?.metroPort && metroResolution ? metroResolution : await resolveOnPort(port, path, lookup);
+		healthy = Boolean(resolution?.metro);
+	}
+	return {
+		pid,
+		mode: state?.mode ?? record?.mode ?? null,
+		startedAt: state?.startedAt ?? record?.startedAt ?? null,
+		alive,
+		healthy
+	};
+}
+function logFacts(path) {
+	const dir = workspaceLogsDir(path);
+	if (!existsSync$1(dir)) return null;
+	try {
+		return {
+			dir,
+			errorsSinceMarker: countErrorsSinceMarker(dir, workspaceLogErrorIndex(path))
+		};
+	} catch {
+		return {
+			dir,
+			errorsSinceMarker: 0
+		};
+	}
+}
+//#endregion
+export { statusCommand as default, readVolumes };