stim 1.14.0 → 1.16.0

package/dist/supervisor-run.mjs

@@ -1,22 +1,150 @@
-import { O as process_identity_exports, U as projectDeviceSlots, V as parseDeviceSlotKey, o as clearSupervisor, p as getProject, w as setSupervisor } from "./config-lvc7d3C2.mjs";
-import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir, b as writeWorkspaceState, h as readWorkspaceState$1, m as clearWorkspaceStateKeys, v as withWorkspaceStateLock } from "./metro-CcEo8Fl8.mjs";
-import { r as detectIsExpo } from "./project-CWlvEaeN.mjs";
+import { B as parseDeviceSlotKey, H as projectDeviceSlots, T as setSupervisor, o as clearSupervisor, p as getProject } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
+import { r as detectIsExpo } from "./project-Du91Ilvc.mjs";
+import { C as workspaceStateFile, a as updateWorkspaceState, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { n as withIdleWorkspace } from "./in-use-DvBw0Kxo.mjs";
+import { r as createActivityReader } from "./activity-BxwdD81S.mjs";
+import { a as parseLease, r as leaseIsExpired, s as parseWorkspaceLeases, t as deviceLeasePath } from "./device-lease-D-hLqx1b.mjs";
+import { l as readPidFile, n as MODE_EXPO, p as writePidFile, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-DcW6vOd_.mjs";
+import { C as parseSubscriberNames, O as runWatchman, T as parseWatchRoots, s as workspaceBuildInProgress, w as parseTriggerCount } from "./idle-DYVymG92.mjs";
+import { z as ownedAvdSerialResolver } from "./android-B_NumVyQ.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
 import { t as describeError } from "./errors-B6W7FkxQ.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-DJHoca49.mjs";
-import { l as readPidFile, n as MODE_EXPO, p as writePidFile, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-DHqvsbqC.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-Blg8IxOh.mjs";
-import { a as parseLease, r as leaseIsExpired, s as parseWorkspaceLeases, t as deviceLeasePath } from "./device-lease-5c3WrVRm.mjs";
-import { n as createActivityReader } from "./activity-CYVDcrt3.mjs";
-import { R as ownedAvdSerialResolver } from "./android-d6rGq1pA.mjs";
-import { c as vanishedSupervisorMessage, i as devServerStopRecord, r as devServerStopLevel, t as describeDevServerStop } from "./stop-cause-hjGBOZTG.mjs";
-import { s as workspaceBuildInProgress } from "./idle-DXtx3RbX.mjs";
-import { n as withIdleWorkspace } from "./in-use-DlqBDKqY.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { c as vanishedSupervisorMessage, i as devServerStopRecord, r as devServerStopLevel, t as describeDevServerStop } from "./stop-cause-CidxIqup.mjs";
+import { l as probeHostedSession } from "./hosted-client-a-WmqE2L.mjs";
+import { t as clearHostedMetro } from "./metro-gateway-BJ-rxQAB.mjs";
+import { n as dueIdleDevices, r as shutDownIdleDevices } from "./idle-shutdown-CTsDnAde.mjs";
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
-import { DEV_SERVER_STOP_REQUEST_KEY, IDLE_STOP_KEY, readDevServerStopRequest } from "@stim-cli/core/state";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { LOG_ROTATE_BYTES, createMetroGateway } from "@stim-cli/core";
+import { DEV_SERVER_STOP_REQUEST_KEY, HOSTED_METRO_GATEWAYS_KEY, HOSTED_METRO_REQUESTS_KEY, IDLE_STOP_KEY, hostedIosPlacements, hostedMetroGateways, hostedMetroRequests, readDevServerStopRequest } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
+//#region src/supervisor/hosted-metro.ts
+function reconcileHostedMetro(requests, active) {
+	const same = (session) => JSON.stringify(requests[session]) === JSON.stringify(active[session]);
+	return {
+		close: Object.keys(active).filter((session) => !same(session)),
+		open: Object.keys(requests).filter((session) => !same(session))
+	};
+}
+function watchHostedMetro(root, metroPort, processToken) {
+	const active = {};
+	const bridges = /* @__PURE__ */ new Map();
+	let closed = false;
+	let running = Promise.resolve();
+	let probingAt = 0;
+	let probing = false;
+	let stamp = "";
+	let cached = null;
+	updateWorkspaceState(root, (state) => state.supervisor?.processToken === processToken ? {
+		...state,
+		supervisor: {
+			...state.supervisor,
+			hostedMetro: true
+		}
+	} : state);
+	const readState = () => {
+		const file = statSync(workspaceStateFile(root));
+		const next = `${file.ino}:${file.mtimeMs}:${file.ctimeMs}:${file.size}`;
+		if (next !== stamp) {
+			cached = readWorkspaceState$1(root);
+			stamp = next;
+		}
+		return cached;
+	};
+	const publish = (session, gateway) => updateWorkspaceState(root, (state) => {
+		const gateways = { ...hostedMetroGateways(state) };
+		if (state.supervisor?.processToken !== processToken) return state;
+		if (gateway) gateways[session] = gateway;
+		else delete gateways[session];
+		return {
+			...state,
+			[HOSTED_METRO_GATEWAYS_KEY]: gateways
+		};
+	});
+	const reconcile = async () => {
+		if (closed) return;
+		const state = readState();
+		if (state?.supervisor?.processToken !== processToken) return;
+		const placements = Object.values(hostedIosPlacements(state));
+		const sessions = new Set(placements.map((placement) => placement.session));
+		const requests = Object.fromEntries(Object.entries(hostedMetroRequests(state)).filter(([session]) => sessions.has(session)));
+		if (Object.keys(requests).length !== Object.keys(hostedMetroRequests(state)).length) updateWorkspaceState(root, (current) => {
+			if (current.supervisor?.processToken !== processToken) return current;
+			const recorded = new Set(Object.values(hostedIosPlacements(current)).map((placement) => placement.session));
+			return {
+				...current,
+				[HOSTED_METRO_REQUESTS_KEY]: Object.fromEntries(Object.entries(hostedMetroRequests(current)).filter(([session]) => recorded.has(session)))
+			};
+		});
+		const actions = reconcileHostedMetro(requests, active);
+		for (const session of actions.close) {
+			await bridges.get(session)?.close();
+			bridges.delete(session);
+			delete active[session];
+			publish(session, null);
+		}
+		for (const session of actions.open) {
+			const request = requests[session];
+			active[session] = request;
+			const bridge = createMetroGateway({
+				metroPort,
+				peer: request.peer,
+				secret: request.secret
+			});
+			bridges.set(session, bridge);
+			try {
+				const saved = hostedMetroGateways(state)[session];
+				await new Promise((resolve, reject) => {
+					bridge.server.once("error", reject);
+					bridge.server.listen(saved?.id === request.id ? saved.port ?? 0 : 0, request.address, () => {
+						bridge.server.removeListener("error", reject);
+						resolve();
+					});
+				});
+				const address = bridge.server.address();
+				if (!address || typeof address === "string") throw new Error("No gateway port.");
+				publish(session, {
+					id: request.id,
+					processToken,
+					port: address.port
+				});
+			} catch {
+				await bridge.close();
+				bridges.delete(session);
+				publish(session, {
+					id: request.id,
+					processToken,
+					error: `Could not bind the private Metro gateway for ${request.machine}. Check Tailscale, then restart Metro.`
+				});
+			}
+		}
+		if (!probing && Date.now() >= probingAt) {
+			probingAt = Date.now() + 1e4;
+			probing = true;
+			Promise.all(placements.map(async (placement) => {
+				if ((await probeHostedSession(placement)).state === "stopped" && !closed) clearHostedMetro(root, placement.session);
+			})).catch(() => {}).finally(() => {
+				probing = false;
+			});
+		}
+	};
+	const tick = () => {
+		running = running.then(reconcile).catch(() => {});
+	};
+	const timer = setInterval(tick, 500);
+	timer.unref();
+	tick();
+	return async () => {
+		closed = true;
+		clearInterval(timer);
+		await running;
+		await Promise.all([...bridges.values()].map((bridge) => bridge.close()));
+	};
+}
+//#endregion
 //#region src/supervisor/idle-stop.ts
 const IDLE_CHECK_MS = 6e4;
 const MINUTE_MS = 6e4;
@@ -80,13 +208,15 @@ function workspaceIdleProbe(root, { platform = process.platform } = {}) {
 			const used = Date.parse(String(readWorkspaceState$1(root)?.lastUsedAt ?? ""));
 			let clientLog = NaN;
 			try {
-				clientLog = statSync(join(workspaceLogsDir(root), "client.ndjson")).mtimeMs;
+				clientLog = statSync(join(workspaceLogsDir$1(root), "client.ndjson")).mtimeMs;
 			} catch {}
 			const times = [used, clientLog].filter(Number.isFinite);
 			return times.length ? Math.max(...times) : NaN;
 		},
 		blocker() {
 			if (workspaceBuildInProgress(root)) return "a build is in progress";
+			const hosted = Object.values(hostedIosPlacements(readWorkspaceState$1(root)))[0];
+			if (hosted) return `its iOS simulator runs on ${hosted.machine}`;
 			const lease = heldDeviceLease(root, Date.now());
 			if (lease) return lease;
 			const readActivity = createActivityReader();
@@ -126,15 +256,163 @@ function watchIdleDevServer({ idleStopMs, now, serverActivityAt, probe, onIdle,
 	timer.unref?.();
 	return () => clearInterval(timer);
 }
+/**
+* Checks each minute, once the workspace has gone `idleMs` without a Stim command, whether an owned device is due
+* for idle shutdown, and runs `onDue` for it.
+*/
+function watchIdleDevices({ idleMs, now, lastUseAt, hasDue, onDue, checkMs = IDLE_CHECK_MS }) {
+	let deciding = false;
+	const timer = setInterval(() => {
+		if (deciding || now() - lastUseAt() < idleMs) return;
+		let due;
+		try {
+			due = hasDue();
+		} catch {
+			return;
+		}
+		if (!due) return;
+		deciding = true;
+		onDue().finally(() => {
+			deciding = false;
+		});
+	}, Math.min(checkMs, idleMs));
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+//#endregion
+//#region src/supervisor/watchman-roots.ts
+const WATCHMAN_TIMEOUT_MS = 2e3;
+const SHUTDOWN_BUDGET_MS = 3e3;
+const PROBE_DELAYS_MS = [
+	3e3,
+	6e3,
+	1e4,
+	15e3,
+	2e4,
+	3e4,
+	45e3,
+	6e4,
+	12e4,
+	3e5
+];
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+function newRootsContaining(before, current, workspaceRoot) {
+	const seen = new Set(before.map((root) => canonical(root) ?? root));
+	return current.filter((root) => {
+		const resolved = canonical(root);
+		if (resolved === null || seen.has(resolved)) return false;
+		return workspaceRoot === resolved || workspaceRoot.startsWith(resolved.endsWith(sep) ? resolved : resolved + sep);
+	});
+}
+function metroSubscriptionPrefix(pid) {
+	return `metro-file-map-${pid}-`;
+}
+async function watchRoots(watchman) {
+	try {
+		return parseWatchRoots(await watchman(["watch-list"]));
+	} catch {
+		return null;
+	}
+}
+async function subscriberNames(watchman, root) {
+	try {
+		return parseSubscriberNames(await watchman(["debug-get-subscriptions", root]));
+	} catch {
+		return null;
+	}
+}
+async function triggerCount(watchman, root) {
+	try {
+		return parseTriggerCount(await watchman(["trigger-list", root]));
+	} catch {
+		return null;
+	}
+}
+function trackMetroWatchRoots({ workspaceRoot, writer, watchman = runWatchman, probeDelaysMs = PROBE_DELAYS_MS }) {
+	let deadline = Infinity;
+	const call = async (args) => {
+		const left = deadline - Date.now();
+		if (left <= 0) throw new Error("the watchman cleanup ran out of time");
+		return watchman(args, Math.min(WATCHMAN_TIMEOUT_MS, left));
+	};
+	const before = watchRoots(call);
+	const owned = /* @__PURE__ */ new Set();
+	const timers = [];
+	let prefix = null;
+	const probe = async () => {
+		const earlier = await before;
+		if (prefix === null || earlier === null) return;
+		const current = await watchRoots(call);
+		if (current === null) return;
+		for (const root of newRootsContaining(earlier, current, workspaceRoot)) {
+			if (owned.has(root)) continue;
+			if ((await subscriberNames(call, root))?.some((name) => name.startsWith(prefix))) owned.add(root);
+		}
+	};
+	return {
+		started(metroPid) {
+			prefix = metroSubscriptionPrefix(metroPid);
+			for (const delay of probeDelaysMs) {
+				const timer = setTimeout(() => void probe(), delay);
+				timer.unref?.();
+				timers.push(timer);
+			}
+		},
+		async beforeClose() {
+			for (const timer of timers) clearTimeout(timer);
+			deadline = Date.now() + SHUTDOWN_BUDGET_MS;
+			await probe();
+		},
+		async afterClose() {
+			for (const root of owned) {
+				const others = (await subscriberNames(call, root))?.filter((name) => !name.startsWith(prefix));
+				const triggers = others?.length === 0 ? await triggerCount(call, root) : null;
+				const reason = !others ? "could not list its subscriptions" : others.length > 0 ? `${others.length} other subscription(s) still use it` : triggers === null ? "could not list its triggers" : triggers > 0 ? `it has ${triggers} trigger(s)` : null;
+				if (reason) {
+					writer.write({
+						src: "metro",
+						level: "debug",
+						event: "watchman_root_kept",
+						msg: `kept the watchman root ${root}: ${reason}`
+					});
+					continue;
+				}
+				try {
+					await call(["watch-del", root]);
+					writer.write({
+						src: "metro",
+						level: "info",
+						event: "watchman_root_removed",
+						msg: `removed the watchman root ${root} that this dev server registered`
+					});
+				} catch (err) {
+					writer.write({
+						src: "metro",
+						level: "warn",
+						event: "watchman_root_kept",
+						msg: `could not remove the watchman root ${root}: ${describeError(err)}`
+					});
+				}
+			}
+		}
+	};
+}
 //#endregion
 //#region src/supervisor/run.ts
-const USAGE = "Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache] [--idle-stop-minutes <n>]";
+const USAGE = "Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache] [--idle-stop-minutes <n>] [--device-idle-minutes <n>]";
 function parseArgs(argv) {
 	let root;
 	let port;
 	let tunnel = false;
 	let resetCache = false;
 	let idleStopMinutes = "0";
+	let deviceIdleMinutes = "0";
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
 		if (arg === "--root") {
@@ -157,24 +435,33 @@ function parseArgs(argv) {
 			idleStopMinutes = argv[++i] ?? "";
 			continue;
 		}
+		if (arg === "--device-idle-minutes") {
+			deviceIdleMinutes = argv[++i] ?? "";
+			continue;
+		}
 		return { error: `Unknown supervisor argument "${arg}". ${USAGE}` };
 	}
 	if (!root) return { error: `Missing --root. ${USAGE}` };
 	if (!isAbsolute(root)) return { error: `--root must be an absolute path, got "${root}".` };
 	const parsedPort = Number(port);
 	if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) return { error: `--port must be a TCP port number, got "${port}".` };
-	if (!/^\d+$/.test(idleStopMinutes)) return { error: `--idle-stop-minutes must be a whole number of minutes, got "${idleStopMinutes}".` };
+	for (const [flag, value] of [["--idle-stop-minutes", idleStopMinutes], ["--device-idle-minutes", deviceIdleMinutes]]) if (!/^\d+$/.test(value)) return { error: `${flag} must be a whole number of minutes, got "${value}".` };
 	return {
 		root: resolve(root),
 		port: parsedPort,
 		tunnel,
 		resetCache,
-		idleStopMinutes: Number(idleStopMinutes)
+		idleStopMinutes: Number(idleStopMinutes),
+		deviceIdleMinutes: Number(deviceIdleMinutes)
 	};
 }
-async function runSupervisor({ root, port, tunnel = false, resetCache = false, idleStopMinutes = 0, idleProbe, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
+const DEVICE_IDLE_OPS = {
+	due: dueIdleDevices,
+	shutDown: shutDownIdleDevices
+};
+async function runSupervisor({ root, port, tunnel = false, resetCache = false, idleStopMinutes = 0, idleProbe, deviceIdleMinutes = 0, deviceIdle = DEVICE_IDLE_OPS, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line), watchman = runWatchman }) {
 	root = realpathSync(root);
-	const logsDir = workspaceLogsDir(root);
+	const logsDir = workspaceLogsDir$1(root);
 	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
 	const mode = isExpo(root) ? MODE_EXPO : MODE_BARE;
 	const startedAt = new Date(now()).toISOString();
@@ -222,12 +509,15 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 	});
 	let stopping = false;
 	let stopWatchingIdle = null;
+	let stopWatchingDevices = null;
+	let closeHostedMetro = null;
 	const stopCause = (trigger) => {
 		const request = readDevServerStopRequest(readWorkspaceState$1(root));
 		return devServerStopRecord(trigger, request?.processToken === processToken ? request : null, new Date(now()).toISOString());
 	};
 	const finish = (code, event, level, msg, stop) => {
 		stopWatchingIdle?.();
+		stopWatchingDevices?.();
 		writer.write({
 			src: "metro",
 			level,
@@ -254,10 +544,18 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		onExit(code);
 	};
 	let server;
+	const watchRoots = trackMetroWatchRoots({
+		workspaceRoot: root,
+		writer,
+		watchman
+	});
 	const shutdown = async (code, event, msg, stop) => {
 		if (stopping || !server) return;
 		stopping = true;
 		stopWatchingIdle?.();
+		stopWatchingDevices?.();
+		await closeHostedMetro?.();
+		await watchRoots.beforeClose();
 		try {
 			await server.close();
 		} catch (err) {
@@ -268,6 +566,7 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 				msg: describeError(err)
 			});
 		}
+		await watchRoots.afterClose();
 		finish(code, event, stop ? devServerStopLevel(stop) : code === 0 ? "info" : "error", msg, stop);
 	};
 	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
@@ -293,7 +592,7 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		return writer.write(entry);
 	} });
 	try {
-		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-DIHDhvGg.mjs")).startExpoServer : startBare || (await import("./server-bare-DGfgyJ5J.mjs")).startBareServer)({
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-CVqO2c35.mjs")).startExpoServer : startBare || (await import("./server-bare-CpPGmnmO.mjs")).startBareServer)({
 			root,
 			port,
 			logsDir,
@@ -342,12 +641,46 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			} });
 		});
 	}
+	watchRoots.started(serverPid ?? process.pid);
 	writer.write({
 		src: "metro",
 		level: "info",
 		event: "server_started",
 		msg: `${mode} dev server listening on port ${port}`
 	});
+	closeHostedMetro = watchHostedMetro(root, port, processToken);
+	const deviceIdleMs = deviceIdleMinutes * 6e4;
+	const workspaceProbe = workspaceIdleProbe(root);
+	const shutDownIdleDevices = (idleMs) => deviceIdle.shutDown(root, idleMs, (entry) => writer.write({
+		src: "metro",
+		...entry
+	}));
+	if (deviceIdleMinutes > 0) stopWatchingDevices = watchIdleDevices({
+		idleMs: deviceIdleMs,
+		now,
+		lastUseAt: () => {
+			let deviceLog = NaN;
+			try {
+				deviceLog = statSync(join(logsDir, "device.ndjson")).mtimeMs;
+			} catch {}
+			const times = [workspaceProbe.lastActivityAt(), deviceLog].filter(Number.isFinite);
+			return times.length ? Math.max(...times) : NaN;
+		},
+		hasDue: () => deviceIdle.due(root, deviceIdleMs).length > 0,
+		onDue: async () => {
+			try {
+				await withIdleWorkspace(root, () => {
+					if (!stopping) shutDownIdleDevices(deviceIdleMs);
+				}, {
+					purpose: "device idle shutdown",
+					supervisor: false,
+					managedLocks: false
+				});
+			} catch (err) {
+				stderr(`Stim supervisor: could not shut down idle devices: ${describeError(err)}`);
+			}
+		}
+	});
 	if (idleStopMinutes > 0) stopWatchingIdle = watchIdleDevServer({
 		idleStopMs: idleStopMinutes * 6e4,
 		now,
@@ -357,6 +690,11 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			const stopIfStillIdle = async () => {
 				const idleMinutes = idleMinutesNow();
 				if (stopping || idleMinutes === null) return;
+				if (deviceIdleMinutes > 0) try {
+					shutDownIdleDevices(Math.min(deviceIdleMs, idleStopMinutes * 6e4));
+				} catch (err) {
+					stderr(`Stim supervisor: could not shut down idle devices: ${describeError(err)}`);
+				}
 				const stop = {
 					reason: "idle",
 					at: new Date(now()).toISOString(),
@@ -422,7 +760,8 @@ async function main(argv = process.argv.slice(2)) {
 		port: parsed.port,
 		tunnel: parsed.tunnel ?? false,
 		resetCache: parsed.resetCache ?? false,
-		idleStopMinutes: parsed.idleStopMinutes ?? 0
+		idleStopMinutes: parsed.idleStopMinutes ?? 0,
+		deviceIdleMinutes: parsed.deviceIdleMinutes ?? 0
 	});
 }
 function invokedDirectly() {