stim 1.8.0 → 1.9.0

package/dist/status-S6ehL4Ui.mjs

@@ -0,0 +1,932 @@
+import { K as projectDeviceSlots, g as loadConfig, u as getConfigDir, z as volumeRootFor } from "./config-Cp9lM3wX.mjs";
+import { t as getExecutor } from "./exec-jIAlgilk.mjs";
+import { a as parseNdjsonLine } from "./ndjson-9uFNRwfe.mjs";
+import { b as workspaceLogsDir, r as readWorkspaceState, y as workspaceLogErrorIndex } from "./workspace-state-DF2gCFhx.mjs";
+import { _ as repoRoot, s as gitCommonDir, y as resolveSourceCheckout } from "./worktree-R_cUlE7s.mjs";
+import { l as projectShortcut, o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { l as readRemoteSession } from "./state-NcJzMEBF.mjs";
+import { c as resolveProjectMetro, i as listeningPidsByPort, o as processCwd, r as listeningPids, s as processCwds, u as isMetroRunning } from "./metro-DrLHaMn2.mjs";
+import { M as ownedAvdSerialResolver, c as androidToolPath } from "./android-_y4Ohi5z.mjs";
+import { a as formatElapsed, r as clockTime, u as plural } from "./command-output-gByVmIjy.mjs";
+import { o as parkedMaxSetting, s as readParked, t as POOL_SETTING_REMEDY } from "./sim-pool-KaIsp2Ft.mjs";
+import { a as buildStatusLine, i as buildReport, o as parseActiveBuild, r as activeBuildState, t as ACTIVE_BUILD_KEY } from "./build-progress-CVqkfPC6.mjs";
+import { d as listAllIosSimsAsync, v as parseSimctlList } from "./ios-BL2NFckr.mjs";
+import { i as listLeaseFiles } from "./device-lease-Crs-HkJY.mjs";
+import { a as statsProjectKey, r as readStats } from "./stats-DG9e66Rz.mjs";
+import { f as easMachineStateRoot, p as readEasSessionLedger } from "./device-remote-AQ5rQPqr.mjs";
+import { d as recordMatches, l as queryLogs, s as logFiles, t as ERROR_SOURCES } from "./logs-query-Cqma3WIu.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-DCQPuWEc.mjs";
+import { i as readSupervisorState } from "./stop-BO28HGqF.mjs";
+import { readdirSync, watch } from "node:fs";
+import { closeSync as closeSync$1, existsSync as existsSync$1, fstatSync, 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 { join } from "path";
+import { rotatedLogPath } from "@stim-cli/core";
+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(), "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(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/status.ts
+const IOS_SIM_MB = 1500;
+const ANDROID_EMULATOR_MB = 2500;
+const METRO_MB = 700;
+function remoteDeviceState(record, ledger, root) {
+	if (!record) return null;
+	const claim = ledger.claims.get(record.sessionId);
+	return {
+		platform: record.platform,
+		backend: "eas",
+		sessionId: record.sessionId,
+		state: !ledger.safe ? "unknown" : claim?.workspaceRoot === root ? "claimed" : "unclaimed",
+		startedAt: record.startedAt,
+		webPreviewUrl: record.webPreviewUrl
+	};
+}
+function poolLine({ platform, parked, max }) {
+	if (parked <= 0) return null;
+	const what = plural(parked, `parked ${platform === "ios" ? "iOS simulator" : "Android emulator"}`);
+	return max > 0 ? `pool: ${what} (max ${max})` : `pool: ${what} (parking off; gc --delete removes them)`;
+}
+function environmentState(project, { simsByUdid = {}, metro = null, worktrees = [], simsAvailable = true, androidRuntime = null, androidRuntimes = {}, supervisor = null, logs = null, remote = null } = {}) {
+	const ios = project.platforms?.ios;
+	const android = project.platforms?.android;
+	const sim = ios ? simsByUdid[ios.deviceUdid] : null;
+	const simBooted = Boolean(sim && sim.state === "Booted");
+	const metroRunning = Boolean(metro?.metro);
+	const androidDetected = androidRuntime ? Boolean(androidRuntime.serial) : Boolean(android?.serial);
+	let live = simBooted || metroRunning || androidDetected || Boolean(remote);
+	let memoryMb = 0;
+	if (simBooted) memoryMb += IOS_SIM_MB;
+	if (androidDetected) memoryMb += ANDROID_EMULATOR_MB;
+	if (metroRunning) memoryMb += METRO_MB;
+	const warnings = [];
+	if (metro?.notOurs) warnings.push(`port ${project.metroPort}: ${metro.notOurs}`);
+	if (ios && !sim && simsAvailable) warnings.push(`recorded sim ${ios.deviceUdid} no longer exists`);
+	if (simBooted && project.metroPort && !metroRunning) warnings.push("simulator is booted with no Metro serving it");
+	if (androidRuntime && android?.avdName) {
+		const recordedSerial = android.consolePort ? `emulator-${android.consolePort}` : android.serial;
+		if (androidRuntime.serial && recordedSerial && androidRuntime.serial !== recordedSerial) warnings.push(`owned AVD ${android.avdName} changed serial (${recordedSerial} -> ${androidRuntime.serial}); rerun your \`stim android\` command in this workspace to restore Metro forwarding, then reopen agent-device on ${androidRuntime.serial}`);
+		if (androidRuntime.state === "missing") warnings.push(`recorded AVD ${android.avdName} no longer exists`);
+		if (androidRuntime.state === "not-detected") warnings.push(`owned AVD ${android.avdName} is not detected by adb; rerun your \`stim android\` command in this workspace to reconnect`);
+		if (androidRuntime.error) warnings.push(`could not check owned AVD ${android.avdName}: ${androidRuntime.error}`);
+	}
+	if (supervisor && supervisor.alive === false) warnings.push(`stale supervisor record for ${project.__path}`);
+	const slots = [];
+	for (const { slot, platforms } of projectDeviceSlots(project).slice(1)) {
+		const deviceState = environmentState({
+			...project,
+			platforms,
+			deviceSlots: void 0
+		}, {
+			simsByUdid,
+			simsAvailable,
+			metro,
+			androidRuntime: androidRuntimes[slot]
+		});
+		slots.push({
+			slot,
+			ios: deviceState.ios,
+			android: deviceState.android
+		});
+		memoryMb += deviceState.memoryMb - (metroRunning ? METRO_MB : 0);
+		live ||= deviceState.live;
+		warnings.push(...deviceState.warnings.map((warning) => `${slot}: ${warning}`));
+	}
+	return {
+		path: project.__path,
+		...slots.length ? { slots } : {},
+		live,
+		memoryMb,
+		warnings,
+		ios: ios ? {
+			name: sim?.name ?? null,
+			udid: ios.deviceUdid,
+			owned: Boolean(ios.owned),
+			state: sim?.state ?? (simsAvailable ? "missing" : "unknown")
+		} : null,
+		android: android ? {
+			name: android.avdName ?? android.serial,
+			owned: Boolean(android.owned),
+			physical: Boolean(android.serial && !android.avdName),
+			...androidRuntime ? {
+				serial: androidRuntime.serial,
+				state: androidRuntime.state
+			} : {}
+		} : null,
+		metro: project.metroPort ? {
+			port: project.metroPort,
+			running: metroRunning,
+			pid: metro?.metro?.pid ?? null
+		} : null,
+		supervisor: supervisor ? {
+			pid: supervisor.pid ?? null,
+			mode: supervisor.mode ?? null,
+			startedAt: supervisor.startedAt ?? null,
+			healthy: Boolean(supervisor.healthy)
+		} : null,
+		logs: logs ? {
+			dir: logs.dir,
+			errorsSinceMarker: logs.errorsSinceMarker ?? 0
+		} : null,
+		worktree: worktrees.find((w) => w.path === project.__path) ?? null,
+		remoteDevices: remote ? [remote] : []
+	};
+}
+function remoteDeviceLine(remote) {
+	const claim = remote.state === "claimed" ? "" : ` (${remote.state})`;
+	const watch = remote.webPreviewUrl ? ` -- watch: ${remote.webPreviewUrl}` : "";
+	return `remote ${remote.platform ?? "?"}: EAS session ${remote.sessionId} billable${claim}${watch}`;
+}
+function capacity(states, totalMemoryMb) {
+	const committedMb = states.reduce((n, s) => n + s.memoryMb, 0);
+	return {
+		liveCount: states.filter((s) => s.live).length,
+		committedMb,
+		totalMemoryMb,
+		overCapacity: Boolean(totalMemoryMb && committedMb > totalMemoryMb * .6)
+	};
+}
+function parseDfFree(output) {
+	const lines = String(output || "").trim().split("\n");
+	if (lines.length < 2) return null;
+	const lastLine = lines[lines.length - 1];
+	if (lastLine === void 0) return null;
+	const m = /\s(\d+)\s+(\d+)\s+(\d+)\s+(\d+)%/.exec(lastLine);
+	if (!m) return null;
+	const totalKb = Number(m[1]);
+	const availableKb = Number(m[3]);
+	if (!Number.isFinite(totalKb) || !Number.isFinite(availableKb) || totalKb <= 0) return null;
+	return {
+		availableMb: Math.round(availableKb / 1024),
+		totalMb: Math.round(totalKb / 1024)
+	};
+}
+function diskIsTight(disk) {
+	return Boolean(disk && disk.availableMb < 25600);
+}
+function formatSpace(mb) {
+	if (!Number.isFinite(mb)) return "?";
+	if (mb >= 1048576) return `${(mb / 1048576).toFixed(1)} TB`;
+	if (mb >= 1024) return `${Math.round(mb / 1024)} GB`;
+	return `${Math.round(mb)} MB`;
+}
+function diskLine(volumes) {
+	const usable = (volumes || []).filter((v) => Boolean(v && v.disk));
+	if (usable.length === 0) return null;
+	if (usable.length === 1) {
+		const first = usable[0];
+		if (!first) return null;
+		const { disk } = first;
+		return `${formatSpace(disk.availableMb)} free of ${formatSpace(disk.totalMb)} on disk.`;
+	}
+	return `${usable.map((v) => `${formatSpace(v.disk.availableMb)} free on ${v.volume}`).join(", ")}.`;
+}
+function tightVolumes(volumes) {
+	return (volumes || []).filter((v) => v && diskIsTight(v.disk));
+}
+function unprovisionedWorktrees(worktrees, projectPaths) {
+	const known = new Set(projectPaths);
+	return worktrees.filter((w) => !known.has(w.path));
+}
+function deviceLeaseStates(entries, { root, now }) {
+	return entries.map((entry) => {
+		const lease = entry.lease;
+		return {
+			path: entry.path,
+			platform: entry.platform,
+			...lease?.slot ? { slot: lease.slot } : {},
+			id: entry.id,
+			deviceName: lease?.deviceName ?? null,
+			holder: lease?.holder ?? null,
+			grantedAt: lease?.grantedAt ?? null,
+			expiresAt: lease?.expiresAt ?? null,
+			mine: Boolean(lease && root && lease.holder === root),
+			expired: Boolean(lease && Date.parse(lease.expiresAt) <= now),
+			parsed: Boolean(lease)
+		};
+	});
+}
+function deviceLeaseLines(states, now) {
+	if (states.length === 0) return [];
+	const lines = [`Device leases (${states.length}):`];
+	for (const state of states) {
+		const device = `${state.platform}${state.slot ? ` [${state.slot}]` : ""} ${state.id ?? state.path}${state.deviceName ? ` (${state.deviceName})` : ""}`;
+		if (!state.parsed || state.expiresAt === null) {
+			lines.push(`  ${device} -- unreadable lease file, so nothing may take the device: ${state.path}`);
+			continue;
+		}
+		const when = clockTime(state.expiresAt);
+		const remaining = Date.parse(state.expiresAt) - now;
+		const expiry = state.expired ? `expired at ${when}` : `until ${when} (${formatElapsed(remaining)} left)`;
+		lines.push(`  ${device} -- ${state.holder} ${expiry}${state.mine ? " [this workspace]" : ""}`);
+	}
+	return lines;
+}
+//#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();
+	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 source = resolveSourceCheckout(process.cwd());
+	const sourcePath = "path" in source ? source.path : null;
+	const worktrees = source.entries.filter((entry) => !entry.bare && entry.path !== sourcePath);
+	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 history = readStats().record?.history;
+	const states = [];
+	const labelOnlyRoots = [];
+	const easLedger = readEasSessionLedger();
+	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)
+		}));
+		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 leaseNow = Date.now();
+	const leases = deviceLeaseStates(listLeaseFiles(), {
+		root: cwdRoot,
+		now: leaseNow
+	});
+	const cap = capacity(states, Math.round(totalmem() / 1048576));
+	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})`) : 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}`);
+			}
+			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)") : ""}`);
+			}
+		}
+		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 workspaceBuild(path, history) {
+	const record = parseActiveBuild(readWorkspaceState(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 };