stim 1.18.0 → 1.20.0

package/dist/status-watch-DvmI3SmN.mjs

@@ -0,0 +1,296 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { d as androidToolPath } from "./android-BsYNR81W.mjs";
+import { b as parseSimctlList } from "./ios-CXLIUxXJ.mjs";
+import { n as easMachineStateRoot } from "./eas-session-ledger-DZlC-Fq3.mjs";
+import { readdirSync, watch } from "node:fs";
+import { join } from "node:path";
+//#region src/status-watch.ts
+const WATCH_FALLBACK_MS = 3e4;
+const WATCH_LIGHT_INTERVAL_MS = 15e3;
+const WATCH_SIMCTL_INTERVAL_MS = 5e3;
+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 full triggers runs `run('full')` 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.
+* A `light` trigger runs `run('light')` no sooner than `debounceMs` from the trigger and `lightIntervalMs` from the
+* start of the previous run, unless a queued full run covers it; later light triggers do not postpone it.
+*/
+function createRefreshScheduler({ debounceMs, lightIntervalMs = 0, run }) {
+	let timer = null;
+	let queued = "full";
+	let running = false;
+	let pending = null;
+	let stopped = false;
+	let lastRunAt = -Infinity;
+	const fire = async () => {
+		timer = null;
+		running = true;
+		lastRunAt = Date.now();
+		try {
+			await run(queued);
+		} finally {
+			running = false;
+			if (pending) {
+				const next = pending;
+				pending = null;
+				trigger(next);
+			}
+		}
+	};
+	function trigger(kind = "full", delayMs = debounceMs) {
+		if (stopped) return;
+		if (running) {
+			pending = pending === "full" ? "full" : kind;
+			return;
+		}
+		if (kind === "light") {
+			if (timer) return;
+			queued = "light";
+			timer = setTimeout(() => void fire(), Math.max(delayMs, lastRunAt + lightIntervalMs - Date.now()));
+			return;
+		}
+		if (timer) clearTimeout(timer);
+		queued = "full";
+		timer = setTimeout(() => void fire(), delayMs);
+	}
+	return {
+		trigger,
+		stop() {
+			stopped = true;
+			if (timer) clearTimeout(timer);
+			timer = null;
+		}
+	};
+}
+/**
+* Which refresh a change to `name` in a watched `$STIM_HOME` directory needs: `light` for a log append or a running
+* build's detail, which can change only the log-derived fields, `full` for anything else that can change the payload,
+* null for none. A null name means the platform did not report one.
+*/
+function statusChange(dir, name) {
+	if (dir === "archive" && (name?.startsWith(".incoming-") || name?.startsWith(".removing-") || name?.startsWith(".lock"))) return null;
+	if (name?.includes(".lock")) return null;
+	if (dir === "logs") return "light";
+	if (name === null) return "full";
+	switch (dir) {
+		case "home":
+			if (name === "maintenance") return "light";
+			return name.startsWith("config.json") || name === "archive" || name === "workspaces" || name === "device-locks" ? "full" : null;
+		case "workspace":
+			if (name.startsWith("build-detail.json")) return "light";
+			return name.startsWith("state.json") || name.startsWith("ended-agents.json") || name === "logs" ? "full" : null;
+		case "maintenance": return name === "state.json" ? "light" : null;
+		case "eas": return name.startsWith("sessions.json") ? "full" : null;
+		default: return "full";
+	}
+}
+/** 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(home, "archive"), "archive"],
+			[join(home, "workspaces"), "workspaces"],
+			[join(home, "maintenance"), "maintenance"],
+			[join(home, "device-locks"), "leases"],
+			[easMachineStateRoot(), "eas"]
+		]);
+		let names = [];
+		try {
+			names = readdirSync(join(home, "workspaces"));
+		} catch {}
+		for (const name of names) {
+			const dir = join(home, "workspaces", name);
+			dirs.set(dir, "workspace");
+			dirs.set(join(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) => {
+					const change = statusChange(kind, name === null ? null : String(name));
+					if (!change) return;
+					if (kind === "home" || kind === "workspaces" || kind === "workspace") {
+						listingStaleBefore = Date.now();
+						reconcile();
+					}
+					onChange(change);
+				});
+				watcher.on("error", () => {
+					watcher.close();
+					watchers.delete(dir);
+				});
+				watchers.set(dir, watcher);
+			} catch {}
+		}
+	};
+	const adb = trackAdbDevices(() => onChange("full"));
+	let simctl = null;
+	let listing = null;
+	let listingStaleBefore = 0;
+	let simTimer = null;
+	if (platform === "darwin") {
+		let last = null;
+		const check = () => {
+			if (simctl || stopped) return;
+			const startedAt = Date.now();
+			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;
+				listing = {
+					at: startedAt,
+					json: out
+				};
+				if (last !== null && signature !== last) onChange("full");
+				last = signature;
+			});
+		};
+		check();
+		simTimer = setInterval(check, simctlIntervalMs);
+	}
+	reconcile();
+	return {
+		reconcile,
+		simulatorListing: () => listing && listing.at > listingStaleBefore && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
+		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");
+	} };
+}
+function ownerKey(owner) {
+	return JSON.stringify([
+		owner.kind,
+		owner.name,
+		owner.workspace,
+		owner.slot ?? null,
+		owner.id,
+		owner.owned
+	]);
+}
+function ownerSteady(before, after) {
+	return Math.abs(after.cpuPercent - before.cpuPercent) < 5 && Math.abs(after.memoryMb - before.memoryMb) < 16;
+}
+/**
+* The payload `status --watch --json` prints. A usage figure keeps its value from the `previous` printed payload until it moves by a step: an owner's `cpuPercent`
+* and `memoryMb`, an environment's `memoryMb` and `capacity.committedMb`. An owner's row is kept whole, `residentMb`
+* and `processes` included, until one of its two figures moves, so a Mac whose processes only jitter prints no new line.
+*/
+function watchPayload(previous, next) {
+	const payload = { ...next };
+	if (!previous) return payload;
+	if (previous.machine && next.machine && previous.machine.memorySource === next.machine.memorySource) {
+		const before = new Map(previous.machine.owners.map((owner) => [ownerKey(owner), owner]));
+		payload.machine = {
+			...next.machine,
+			owners: next.machine.owners.map((owner) => {
+				const old = before.get(ownerKey(owner));
+				return old && ownerSteady(old, owner) ? old : owner;
+			})
+		};
+	}
+	const memory = new Map(previous.environments.map((env) => [env.path, env]));
+	payload.environments = payload.environments.map((env) => {
+		const old = memory.get(env.path);
+		return old && old.memorySource === env.memorySource && Math.abs(env.memoryMb - old.memoryMb) < 16 ? {
+			...env,
+			memoryMb: old.memoryMb
+		} : env;
+	});
+	const { capacity } = previous;
+	if (capacity.overCapacity === next.capacity.overCapacity && capacity.liveCount === next.capacity.liveCount && capacity.totalMemoryMb === next.capacity.totalMemoryMb && Math.abs(next.capacity.committedMb - capacity.committedMb) < 16) payload.capacity = capacity;
+	return payload;
+}
+//#endregion
+export { watchStatusSources as a, watchPayload as i, WATCH_LIGHT_INTERVAL_MS as n, createRefreshScheduler as r, WATCH_FALLBACK_MS as t };

package/dist/{stim-desktop-Behws_fi.mjs → stim-desktop-8GQX2OV8.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 //#region src/devices/stim-desktop.ts
 const LAUNCH_SERVICES_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier('dev.stim.desktop'); url.isNil() ? '' : url.path.js`;
 const SCHEME_HANDLER_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL($.NSURL.URLWithString('stim-desktop://workspace')); url.isNil() ? '' : url.path.js`;

package/dist/{stop-DIJtD2GL.mjs → stop-CCZS-C9m.mjs}

@@ -1,3 +1,3 @@
-import { m as resolveSupervisorTarget } from "./workspaces-xXItD8Dj.mjs";
-import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BTjs3xbc.mjs";
+import { P as resolveSupervisorTarget } from "./workspaces-D2xSHBDY.mjs";
+import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-iNemHsJC.mjs";
 export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop, stopWorkspaceNow };

package/dist/stop-WQPQHLuy.mjs

@@ -0,0 +1,72 @@
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { c as writeWorkspaceState, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { m as runningBundleInstances } from "./workspaces-D2xSHBDY.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-C2lvoPsb.mjs";
+import { a as macosRuntimeClaim, o as requiredMacosRecord } from "./state-Boo0IMJq.mjs";
+import { n as stopHostedMacos } from "./hosted-macos-Aziw9T_9.mjs";
+import { readMacosRecord } from "@stim-cli/core/state";
+//#region src/macos/stop.ts
+const APP_EXIT_MS = 5e3;
+const SUPERVISOR_EXIT_MS = 12e3;
+function signal(pid, name) {
+	try {
+		process.kill(pid, name);
+	} catch (error) {
+		if (error.code !== "ESRCH") throw error;
+	}
+}
+async function stopProcesses(records, waitMs = APP_EXIT_MS) {
+	let live = [...new Map(records.map((record) => [record.pid, record])).values()];
+	for (const name of ["SIGTERM", "SIGKILL"]) {
+		live = live.filter((record) => {
+			const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
+			if (identity === "gone" || identity === "different") return false;
+			if (identity !== "same") throw Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS owner pid ${record.pid}; no signal was sent.`), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+			return true;
+		});
+		for (const record of live) signal(record.pid, name);
+		const exited = await Promise.all(live.map((record) => (0, process_identity_exports.waitForProcessExit)(record, waitMs)));
+		live = live.filter((_, index) => !exited[index]);
+		if (!live.length) return;
+	}
+	throw new Error(`Owned macOS process ${live.map((record) => record.pid).join(", ")} did not exit.`);
+}
+/** Stops every running copy of the workspace's owned app bundle, including copies LaunchServices started. */
+async function stopBundleInstances(root) {
+	const instances = runningBundleInstances(root);
+	await stopProcesses(instances);
+	return instances.length > 0;
+}
+async function stopMacosAppHeld(root) {
+	const record = requiredMacosRecord(root);
+	if (record?.supervisor) await stopProcesses([record.supervisor], SUPERVISOR_EXIT_MS);
+	const app = readMacosRecord(root)?.app ?? record?.app;
+	if (app) await stopProcesses([app]);
+	const instances = runningBundleInstances(root);
+	await stopProcesses(instances);
+	if (!record) return instances.length > 0;
+	const claims = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
+	if (claims.unresolved.length || claims.live.length) throw Object.assign(/* @__PURE__ */ new Error("The macOS runtime claim cannot be released; inspect its recorded owner before cleanup."), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+	return true;
+}
+/** Stops the workspace's app here, or its session on the hosting Mac, which must confirm the session stopped. */
+function stopMacosApp(root) {
+	const stop = async () => {
+		const record = requiredMacosRecord(root);
+		if (!record?.host) return stopMacosAppHeld(root);
+		await stopHostedMacos(root, record.host);
+		const { host: _host, hostLaunched: _launched, ...stopped } = record;
+		writeWorkspaceState(root, { macos: {
+			...stopped,
+			supervisor: void 0
+		} });
+		return true;
+	};
+	return withWorkspaceProcessLock(workspaceDir(root), "macos-launch", stop, {
+		external: true,
+		waitMs: 0,
+		ownerPurpose: "stop macOS app"
+	});
+}
+//#endregion
+export { stopMacosApp as n, stopMacosAppHeld as r, stopBundleInstances as t };

package/dist/{stop-BTjs3xbc.mjs → stop-iNemHsJC.mjs}

@@ -1,20 +1,22 @@
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-CBtzyIgF.mjs";
-import { B as parseDeviceSlotKey, D as withConfigLock$1, E as upsertProject, H as projectDeviceSlots, V as parseDeviceSlotOption, W as validateDeviceSlot, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-CgYMahz7.mjs";
-import { o as findCommandWorkspace } from "./project-C3ChRLZy.mjs";
-import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-Dh8T4Ytd.mjs";
-import { a as updateWorkspaceState, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-C59dqG-Z.mjs";
-import { Bt as clearWorkspaceLaunches, Ht as readMetroTunnel, Rt as clearManagedMetroTunnel, Vt as clearWorkspaceSupervisor, Wt as readRemoteSession, b as withdrawDevServerStopRequest, g as logVanishedSupervisor, v as requestDevServerStop, zt as clearRemoteSession } from "./budget-DIhL2BKx.mjs";
-import { D as teardownOwnedBrowser, E as teardownOwnedAvd, O as teardownOwnedIosSim, g as stopTunnel, m as resolveSupervisorTarget } from "./workspaces-xXItD8Dj.mjs";
-import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-Co-EwifR.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-BFIz1Shz.mjs";
-import { i as stopHostedAndroid } from "./hosted-android-Bv285t_t.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-BGg7aGIZ.mjs";
-import { i as endRecordedSession } from "./device-remote-tHbd1fKy.mjs";
-import { a as decideStopAction, c as nativeRunWaitNotice, i as clearNativeRunCancel, l as requestNativeRunCancel, n as NATIVE_RUN_WAIT_MS, o as describeNativeRunHolder, s as nativeRunHolder, t as NATIVE_RUN_LOCK } from "./native-run-B06FkmZx.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-D6Se7gg_.mjs";
-import { r as stopHostedIos } from "./hosted-ios-D5mNmtj4.mjs";
-import { t as stopMacosApp } from "./stop-BGhKMOuH.mjs";
+import { n as debugLog } from "./exec-B81Qodjn.mjs";
+import { B as parseDeviceSlotKey, D as withConfigLock$1, E as upsertProject, H as projectDeviceSlots, V as parseDeviceSlotOption, W as validateDeviceSlot, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-DHOBXGgS.mjs";
+import { a as updateWorkspaceState, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-BjPN99ZB.mjs";
+import { A as clearWorkspaceSupervisor, D as clearManagedMetroTunnel, N as readRemoteSession, O as clearRemoteSession, j as readMetroTunnel, k as clearWorkspaceLaunches, n as findCommandWorkspace, w as MODE_COMMAND } from "./project-B8_duAzW.mjs";
+import { d as signalProcessTree, r as killMetroTree, s as pidExists, u as resolveProjectMetro } from "./metro-D_j9sN-B.mjs";
+import { D as stopTunnel, P as resolveSupervisorTarget, b as teardownOwnedIosSim, v as teardownOwnedAvd, y as teardownOwnedBrowser } from "./workspaces-D2xSHBDY.mjs";
+import { _t as withdrawDevServerStopRequest, ht as requestDevServerStop, pt as logVanishedSupervisor } from "./budget-BONq9vXY.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-C2lvoPsb.mjs";
+import { _ as nativeRunHolder, d as NATIVE_RUN_LOCK, f as NATIVE_RUN_WAIT_MS, g as describeNativeRunHolder, h as decideStopAction, m as clearNativeRunCancel, v as nativeRunWaitNotice, y as requestNativeRunCancel } from "./tailnet-CoJUb2tB.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-Bsts6f6Y.mjs";
+import { t as macosAppPresent } from "./state-Boo0IMJq.mjs";
+import { i as stopHostedAndroid } from "./hosted-android-DQ-Agsd8.mjs";
+import { i as endRecordedSession } from "./device-remote-Bmg42063.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-DXzMMSx6.mjs";
+import { r as stopHostedIos } from "./hosted-ios-DIxFnYp-.mjs";
+import { n as stopMacosApp } from "./stop-WQPQHLuy.mjs";
 import { hostedAndroidDeviceName, hostedAndroidRecords, hostedIosRecords, hostedNativeRecords, isJsonObject, parseHostedNativePlacement } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/stop.ts
@@ -249,10 +251,9 @@ async function stopWorkspaceHostedNative(root, slot, report, failed) {
 	};
 }
 async function stopWorkspaceMacos(root, failed, enabled) {
-	if (enabled === false || readWorkspaceState$1(root)?.macos === void 0) return void 0;
+	if (enabled === false || !macosAppPresent(root)) return void 0;
 	try {
-		await stopMacosApp(root);
-		return { status: "stopped" };
+		return await stopMacosApp(root) ? { status: "stopped" } : void 0;
 	} catch (error) {
 		const reason = error instanceof Error ? error.message : String(error);
 		failed(reason);
@@ -262,7 +263,7 @@ async function stopWorkspaceMacos(root, failed, enabled) {
 		};
 	}
 }
-async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, hostedSlot, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid, group) => signalProcessTree(pid, "SIGTERM", { group }), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, hostedSlot, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
 	const proj = project === void 0 ? getProject(root) : project;
 	const sup = state === void 0 ? readSupervisorState(root) : state;
 	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
@@ -292,6 +293,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	let ok = true;
 	let stillHolding = null;
 	let keepPort = null;
+	debugLog.log("stop.phase.start", { phase: "supervisor" });
 	const target = resolveSupervisorTarget({
 		state: sup,
 		record: proj?.supervisor ?? null,
@@ -329,6 +331,11 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			stillHolding = outcomes.supervisor.reason;
 		}
 	}
+	debugLog.log("stop.phase.end", {
+		phase: "supervisor",
+		status: outcomes.supervisor.status
+	});
+	debugLog.log("stop.phase.start", { phase: "collectors" });
 	outcomes.collectors = await reapCollectors(root, collectorRecords, {
 		isAlive,
 		signal: signalCollector,
@@ -344,10 +351,22 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	} else if (outcomes.collectors.entries.some((entry) => entry.status === "failed")) {
 		ok = false;
 		stillHolding ??= "a collector could not be stopped";
-	} else if (outcomes.collectors.entries.length && clearCollectors(root, collectorRecords) === false) {
-		ok = false;
-		stillHolding ??= "a replacement collector appeared during cleanup";
+	} else if (outcomes.collectors.entries.length) {
+		debugLog.log("stop.phase.start", { phase: "clear-collectors" });
+		const cleared = clearCollectors(root, collectorRecords);
+		debugLog.log("stop.phase.end", {
+			phase: "clear-collectors",
+			cleared
+		});
+		if (cleared === false) {
+			ok = false;
+			stillHolding ??= "a replacement collector appeared during cleanup";
+		}
 	}
+	debugLog.log("stop.phase.end", {
+		phase: "collectors",
+		status: outcomes.collectors.status
+	});
 	if (outcomes.supervisor.status === "stopped" || outcomes.supervisor.status === "timeout" || outcomes.supervisor.status === "unverified" || outcomes.supervisor.status === "failed") outcomes.metro = {
 		status: "skipped",
 		reason: "the supervisor owns the dev server on this port"
@@ -627,6 +646,7 @@ async function stopSupervisor(target, { root, killGroup, waiter, report }) {
 	const reason = `supervisor pid ${target.pid} did not exit within ${Math.round(DEFAULT_WAIT_MS / 1e3)}s of SIGTERM`;
 	report(chalk.red(phaseLine("stop", reason)));
 	report(chalk.dim(phaseLine("", `inspect it with \`ps -p ${target.pid}\`, or signal it yourself: kill -9 -${target.pid}`)));
+	if (target.mode === "command-child") report(chalk.dim(phaseLine("", "metro.command runs in its own process group: once the supervisor is gone, run stim stop again to stop it")));
 	return {
 		status: "timeout",
 		pid: target.pid,
@@ -659,7 +679,7 @@ async function stopMetro(port, root, { server, supervisorGone, signalServer, ins
 		report(chalk.dim(phaseLine("metro", `sending SIGTERM to dev server pid ${serverPid} left by the supervisor`)));
 		let signalled = false;
 		try {
-			signalled = signalServer(serverPid);
+			signalled = signalServer(serverPid, server?.mode === MODE_COMMAND);
 		} catch {}
 		if (signalled ? await waiter(serverPid, serverProcessToken) : ["gone", "different"].includes(inspectIdentity(serverRecord))) {
 			report(chalk.green(phaseLine("metro", `dev server pid ${serverPid}`)));
@@ -731,11 +751,25 @@ function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report
 					reason: "Stim does not own this device"
 				};
 				report(chalk.dim(phaseLine("device", `${iosUdid} is not Stim-owned, leaving it running`)));
-			} else device[iosKey] = reportDevice(iosUdid, teardownIos(iosUdid, {
-				del: false,
-				label: iosName,
-				workspace
-			}), report, "ios");
+			} else {
+				debugLog.log("stop.device.start", {
+					platform: "ios",
+					slot,
+					deviceId: iosUdid
+				});
+				const result = teardownIos(iosUdid, {
+					del: false,
+					label: iosName,
+					workspace
+				});
+				debugLog.log("stop.device.end", {
+					platform: "ios",
+					slot,
+					deviceId: iosUdid,
+					status: result.status
+				});
+				device[iosKey] = reportDevice(iosUdid, result, report, "ios");
+			}
 		}
 		const android = platforms.android;
 		if (android?.avdName) {
@@ -747,10 +781,24 @@ function shutDownDevices(project, workspace, { teardownIos, teardownAvd, report
 					reason: "Stim does not own this device"
 				};
 				report(chalk.dim(phaseLine("device", `${android.avdName} is not Stim-owned, leaving it running`)));
-			} else device[androidKey] = reportDevice(android.avdName, teardownAvd(android.avdName, {
-				del: false,
-				workspace
-			}), report, "android");
+			} else {
+				debugLog.log("stop.device.start", {
+					platform: "android",
+					slot,
+					deviceId: android.avdName
+				});
+				const result = teardownAvd(android.avdName, {
+					del: false,
+					workspace
+				});
+				debugLog.log("stop.device.end", {
+					platform: "android",
+					slot,
+					deviceId: android.avdName,
+					status: result.status
+				});
+				device[androidKey] = reportDevice(android.avdName, result, report, "android");
+			}
 		}
 	}
 	return device;

package/dist/supervisor-run.d.mts

@@ -1,4 +1,4 @@
-import { a as readPidFile, i as clearWorkspaceSupervisor, n as MODE_EXPO, o as writePidFile, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-lKh8shBp.mjs";
+import { a as clearWorkspaceSupervisor, i as clearExpoMetroTunnel, n as MODE_BARE, o as readPidFile, r as MODE_EXPO, s as writePidFile, t as SettingsObject } from "./settings-vk3mJGSm.mjs";
 import { t as NdjsonWriter } from "./ndjson-Du3j0AQ9.mjs";
 import { DevServerStopRecord, DeviceActivity, DeviceIdleShutdownRecord, IOS_SIMULATOR_APPS } from "@stim-cli/core/state";
 //#region src/supervisor/types.d.ts
@@ -21,6 +21,7 @@ type ServerStarter = (opts: {
   tunnel?: boolean;
   resetCache?: boolean;
   onTunnelUrl?: ((url: string) => void) | null;
+  settings?: SettingsObject;
 }) => Promise<ServerHandle>;
 //#endregion
 //#region src/supervisor/idle-stop.d.ts
@@ -91,13 +92,17 @@ interface RunSupervisorOptions {
   isExpo?: (projectRoot: string) => boolean;
   startBare?: ServerStarter | null;
   startExpo?: ServerStarter | null;
+  startCommand?: ((opts: Parameters<ServerStarter>[0] & {
+    command: readonly string[];
+  }) => Promise<ServerHandle>) | null;
+  settings?: SettingsObject | null;
   now?: () => number;
   onExit?: (code: number) => void;
   attachSignals?: boolean;
   stderr?: (line: string) => void;
   watchman?: WatchmanCommand;
 }
-declare function runSupervisor({ root, port, tunnel, resetCache, idleStopMinutes, idleProbe, deviceIdleMinutes, deviceIdle, isExpo, startBare, startExpo, now, onExit, attachSignals, stderr, watchman }: RunSupervisorOptions): Promise<{
+declare function runSupervisor({ root, port, tunnel, resetCache, idleStopMinutes, idleProbe, deviceIdleMinutes, deviceIdle, isExpo, startBare, startExpo, startCommand, settings: settingsOverride, now, onExit, attachSignals, stderr, watchman }: RunSupervisorOptions): Promise<{
   mode: string;
   server: ServerHandle | undefined;
   shutdown: (code: number, event: string, msg: string, stop?: DevServerStopRecord) => Promise<void>;