stim 1.8.0 → 1.10.0

package/dist/supervisor-run.mjs

@@ -1,19 +1,139 @@
-import { a as clearSupervisor, w as process_identity_exports, x as setSupervisor } from "./config-B7iyKWkL.mjs";
-import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { _ as workspaceLogsDir, a as withWorkspaceStateLock, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { i as detectIsExpo } from "./project-DDZWf_16.mjs";
+import { B as parseDeviceSlotKey, C as setSupervisor, D as process_identity_exports, H as projectDeviceSlots, a as clearSupervisor, f as getProject } from "./config-BEq0Qw_a.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { _ as withWorkspaceStateLock, j as workspaceLogsDir, m as readWorkspaceState$1, p as clearWorkspaceStateKeys, y as writeWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { a as detectIsExpo } from "./project-BXZzOABt.mjs";
 import { t as describeError } from "./errors-B6W7FkxQ.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-Bpo6ZY_I.mjs";
-import { c as readPidFile, f as writePidFile, n as MODE_EXPO, o as clearWorkspaceSupervisor, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-DZobzxLW.mjs";
-import { existsSync, realpathSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { t as relaunchWithLogFile } from "./detached-entry-DJHoca49.mjs";
+import { c as readPidFile, f as writePidFile, n as MODE_EXPO, o as clearWorkspaceSupervisor, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-WGdIbi_d.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
+import { a as parseLease, r as leaseIsExpired, s as parseWorkspaceLeases, t as deviceLeasePath } from "./device-lease-CbEaIk7b.mjs";
+import { c as createActivityReader } from "./build-progress-BXx-ZBe4.mjs";
+import { N as ownedAvdSerialResolver } from "./android-787HhP5w.mjs";
+import { s as workspaceBuildInProgress } from "./idle-DpRLp5lj.mjs";
+import { n as withIdleWorkspace } from "./in-use-CjUluqIX.mjs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { IDLE_STOP_KEY } from "@stim-cli/core/state";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+//#region src/supervisor/idle-stop.ts
+const IDLE_CHECK_MS = 6e4;
+const MINUTE_MS = 6e4;
+function trackDevServerActivity(now) {
+	let last = now();
+	const open = /* @__PURE__ */ new Set();
+	return {
+		record(entry) {
+			const { event, requestId } = entry ?? {};
+			if (event === "bundle_response_started") {
+				if (typeof requestId === "string") open.add(requestId);
+			} else if (event === "bundle_response_finished" || event === "bundle_response_failed") {
+				if (typeof requestId === "string") open.delete(requestId);
+			} else if (event !== "expo_stdout") return;
+			last = now();
+		},
+		lastActivityAt: () => open.size > 0 ? now() : last
+	};
+}
+function deviceTargets(root) {
+	const serialOf = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return projectDeviceSlots(getProject(root)).flatMap(({ slot, platforms }) => {
+		const targets = [];
+		if (platforms.ios?.deviceUdid) targets.push({
+			platform: "ios",
+			id: platforms.ios.deviceUdid,
+			slot
+		});
+		const android = platforms.android;
+		const serial = android?.avdName ? serialOf(android.avdName).serial : android?.serial;
+		if (serial) targets.push({
+			platform: "android",
+			id: serial,
+			slot
+		});
+		return targets;
+	});
+}
+function heldDeviceLease(root, now) {
+	for (const [key, record] of Object.entries(parseWorkspaceLeases(readWorkspaceState$1(root)?.deviceLeases))) {
+		const platform = parseDeviceSlotKey(key)?.platform;
+		if (!platform) continue;
+		let raw;
+		try {
+			raw = readFileSync(deviceLeasePath(platform, record.id), "utf8");
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			return `${platform} device ${record.id} has a lease that cannot be read (${describeError(error)})`;
+		}
+		const lease = parseLease(raw);
+		if (!lease) return `${platform} device ${record.id} has a lease that cannot be read`;
+		if (lease.token !== record.token || leaseIsExpired(lease, now)) continue;
+		const by = record.kind === "declared" ? "stim device lock" : "a stim ios or android run";
+		return `${platform} device ${record.id} is leased by ${by} until ${lease.expiresAt}`;
+	}
+	return null;
+}
+function workspaceIdleProbe(root, { platform = process.platform } = {}) {
+	return {
+		lastActivityAt() {
+			const used = Date.parse(String(readWorkspaceState$1(root)?.lastUsedAt ?? ""));
+			let clientLog = NaN;
+			try {
+				clientLog = statSync(join(workspaceLogsDir(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 lease = heldDeviceLease(root, Date.now());
+			if (lease) return lease;
+			const readActivity = createActivityReader();
+			for (const target of deviceTargets(root)) {
+				const activity = readActivity({
+					...target,
+					workspace: root
+				});
+				if (activity.state === "driven") return `${target.platform} device ${target.id} is driven by ${activity.driver?.tool ?? "an unknown tool"}`;
+				const unknown = platform === "win32" ? activity.basis.filter((basis) => basis !== "driver-process") : activity.basis;
+				if (activity.state === "unknown" && unknown.length > 0) return `${target.platform} device ${target.id} has unknown activity (${unknown.join(", ")})`;
+			}
+			return null;
+		}
+	};
+}
+function watchIdleDevServer({ idleStopMs, now, serverActivityAt, probe, onIdle, checkMs = IDLE_CHECK_MS }) {
+	const idleMinutes = () => {
+		const last = Math.max(serverActivityAt(), ...[probe.lastActivityAt()].filter(Number.isFinite));
+		if (now() - last < idleStopMs) return null;
+		let blocker;
+		try {
+			blocker = probe.blocker();
+		} catch (error) {
+			blocker = describeError(error);
+		}
+		return blocker ? null : Math.floor((now() - last) / MINUTE_MS);
+	};
+	let deciding = false;
+	const timer = setInterval(() => {
+		if (deciding || idleMinutes() === null) return;
+		deciding = true;
+		onIdle(idleMinutes).finally(() => {
+			deciding = false;
+		});
+	}, Math.min(checkMs, idleStopMs));
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+//#endregion
 //#region src/supervisor/run.ts
+const USAGE = "Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache] [--idle-stop-minutes <n>]";
 function parseArgs(argv) {
 	let root;
 	let port;
 	let tunnel = false;
 	let resetCache = false;
+	let idleStopMinutes = "0";
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
 		if (arg === "--root") {
@@ -32,23 +152,29 @@ function parseArgs(argv) {
 			resetCache = true;
 			continue;
 		}
-		return { error: `Unknown supervisor argument "${arg}". Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache]` };
+		if (arg === "--idle-stop-minutes") {
+			idleStopMinutes = argv[++i] ?? "";
+			continue;
+		}
+		return { error: `Unknown supervisor argument "${arg}". ${USAGE}` };
 	}
-	if (!root) return { error: "Missing --root. Usage: run.js --root <path> --port <n> [--tunnel] [--reset-cache]" };
+	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}".` };
 	return {
 		root: resolve(root),
 		port: parsedPort,
 		tunnel,
-		resetCache
+		resetCache,
+		idleStopMinutes: Number(idleStopMinutes)
 	};
 }
-async function runSupervisor({ root, port, tunnel = false, resetCache = false, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
+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) }) {
 	root = realpathSync(root);
 	const logsDir = workspaceLogsDir(root);
-	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"));
+	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();
 	const processToken = (0, process_identity_exports.captureProcessToken)(process.pid);
@@ -68,6 +194,7 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 	clearExpoMetroTunnel(root);
 	writePidFile(root, process.pid);
 	writeWorkspaceState(root, { supervisor: record });
+	clearWorkspaceStateKeys(root, [IDLE_STOP_KEY]);
 	try {
 		setSupervisor(root, record);
 	} catch (err) {
@@ -86,7 +213,9 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		msg: `supervisor pid ${process.pid} starting the ${mode} dev server on port ${port} for ${root}`
 	});
 	let stopping = false;
+	let stopWatchingIdle = null;
 	const finish = (code, event, level, msg) => {
+		stopWatchingIdle?.();
 		writer.write({
 			src: "metro",
 			level,
@@ -104,18 +233,48 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		onExit(code);
 	};
 	let server;
+	const shutdown = async (code, event, msg) => {
+		if (stopping || !server) return;
+		stopping = true;
+		stopWatchingIdle?.();
+		try {
+			await server.close();
+		} catch (err) {
+			writer.write({
+				src: "metro",
+				level: "warn",
+				event: "server_close_failed",
+				msg: describeError(err)
+			});
+		}
+		finish(code, event, code === 0 ? "info" : "error", msg);
+	};
+	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+		if (server) {
+			shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
+			return;
+		}
+		if (stopping) return;
+		stopping = true;
+		finish(signal === "SIGINT" ? 130 : 143, "supervisor_stopped", "warn", `received ${signal} before the ${mode} dev server started; stopping`);
+	});
+	const serverActivity = trackDevServerActivity(now);
+	const serverWriter = Object.assign(Object.create(writer), { write(entry) {
+		serverActivity.record(entry);
+		return writer.write(entry);
+	} });
 	try {
-		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-YDDG3eP7.mjs")).startExpoServer : startBare || (await import("./server-bare-BQkyxa_b.mjs")).startBareServer)({
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-DBVTdult.mjs")).startExpoServer : startBare || (await import("./server-bare-DVbb7kXH.mjs")).startBareServer)({
 			root,
 			port,
 			logsDir,
-			writer,
+			writer: serverWriter,
 			tunnel,
 			resetCache,
 			onTunnelUrl: (url) => {
 				try {
 					withWorkspaceStateLock(root, () => {
-						if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { metroTunnel: {
+						if (readWorkspaceState$1(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { metroTunnel: {
 							kind: "expo",
 							url
 						} });
@@ -132,46 +291,72 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			}
 		});
 	} catch (err) {
+		if (stopping) return null;
 		stderr(`Stim supervisor: failed to start the ${mode} dev server: ${describeError(err)}`);
 		finish(1, "supervisor_failed", "fatal", `failed to start the ${mode} dev server: ${describeError(err)}`);
 		return null;
 	}
-	const readyServer = server;
-	if (readyServer.serverPid) withWorkspaceStateLock(root, () => {
-		if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { supervisor: {
-			...record,
-			serverPid: readyServer.serverPid
-		} });
-	});
+	if (stopping) {
+		try {
+			await server.close();
+		} catch {}
+		return null;
+	}
+	const serverPid = server.serverPid;
+	if (serverPid) {
+		const serverProcessToken = (0, process_identity_exports.captureProcessToken)(serverPid);
+		withWorkspaceStateLock(root, () => {
+			if (readWorkspaceState$1(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { supervisor: {
+				...record,
+				serverPid,
+				...serverProcessToken ? { serverProcessToken } : {}
+			} });
+		});
+	}
 	writer.write({
 		src: "metro",
 		level: "info",
 		event: "server_started",
 		msg: `${mode} dev server listening on port ${port}`
 	});
-	const shutdown = async (code, event, msg) => {
-		if (stopping) return;
-		stopping = true;
-		try {
-			await readyServer.close();
-		} catch (err) {
-			writer.write({
-				src: "metro",
-				level: "warn",
-				event: "server_close_failed",
-				msg: describeError(err)
-			});
+	if (idleStopMinutes > 0) stopWatchingIdle = watchIdleDevServer({
+		idleStopMs: idleStopMinutes * 6e4,
+		now,
+		serverActivityAt: serverActivity.lastActivityAt,
+		probe: idleProbe ?? workspaceIdleProbe(root),
+		onIdle: async (idleMinutesNow) => {
+			const stopIfStillIdle = async () => {
+				const idleMinutes = idleMinutesNow();
+				if (stopping || idleMinutes === null) return;
+				withWorkspaceStateLock(root, () => {
+					if (readWorkspaceState$1(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { [IDLE_STOP_KEY]: {
+						reason: "idle",
+						at: new Date(now()).toISOString(),
+						idleMinutes
+					} });
+				});
+				await shutdown(0, "supervisor_idle_stopped", `no bundle request, client log or Stim command for ${idleMinutes} minutes (metro.idleStopMinutes is ${idleStopMinutes}); stopped the ${mode} dev server`);
+			};
+			try {
+				await withIdleWorkspace(root, () => withWorkspaceProcessLock(dirname(logsDir), "metro-start", stopIfStillIdle, {
+					external: true,
+					waitMs: 0,
+					ownerPurpose: "idle stop"
+				}), {
+					purpose: "idle stop",
+					supervisor: false,
+					managedLocks: false
+				});
+			} catch (err) {
+				stderr(`Stim supervisor: could not stop the idle dev server: ${describeError(err)}`);
+			}
 		}
-		finish(code, event, code === 0 ? "info" : "error", msg);
-	};
-	readyServer.onExit?.((info) => {
+	});
+	server.onExit?.((info) => {
 		if (stopping) return;
 		const detail = info?.signal ? `signal ${info.signal}` : `exit code ${info?.code ?? "unknown"}`;
 		shutdown(1, "supervisor_stopped", `the ${mode} dev server exited unexpectedly (${detail}); shutting the supervisor down`);
 	});
-	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
-		shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
-	});
 	return {
 		mode,
 		server,
@@ -201,7 +386,8 @@ async function main(argv = process.argv.slice(2)) {
 		root,
 		port: parsed.port,
 		tunnel: parsed.tunnel ?? false,
-		resetCache: parsed.resetCache ?? false
+		resetCache: parsed.resetCache ?? false,
+		idleStopMinutes: parsed.idleStopMinutes ?? 0
 	});
 }
 function invokedDirectly() {

package/dist/{workspace-process-lock-BYfZz_S-.mjs → workspace-process-lock-BXA96myD.mjs}

@@ -1,4 +1,5 @@
-import { E as ownership_claim_exports } from "./config-B7iyKWkL.mjs";
+import { k as ownership_claim_exports } from "./config-BEq0Qw_a.mjs";
+import { r as stopDeclaringSpawnsOn, t as declareSpawnsOn } from "./spawn-claims-CUleC2cM.mjs";
 import { join } from "node:path";
 //#region src/engine/workspace-process-lock.ts
 const DEFAULT_WAIT_MS = 6e4;
@@ -10,11 +11,11 @@ function workspaceProcessLockError(err) {
 	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
 	return null;
 }
-function lockPath(root, name, external) {
+function workspaceProcessLockPath(root, name, external) {
 	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
 }
-async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, rejectOwnerPurposes = [], external = false } = {}) {
-	const path = lockPath(root, name, external);
+async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
 	const deadline = now() + waitMs;
 	for (;;) {
 		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
@@ -24,10 +25,14 @@ async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep
 			details: ownerPurpose ? { purpose: ownerPurpose } : {}
 		});
 		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		if (attempt.acquired) try {
-			return await fn();
-		} finally {
-			(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+		if (attempt.acquired) {
+			if (declareSpawns) declareSpawnsOn(attempt.acquired);
+			try {
+				return await fn(attempt.acquired);
+			} finally {
+				stopDeclaringSpawnsOn(attempt.acquired);
+				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+			}
 		}
 		const purpose = (attempt.held ?? attempt.waitingFor?.[0])?.details.purpose;
 		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
@@ -44,4 +49,4 @@ async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep
 	}
 }
 //#endregion
-export { workspaceProcessLockError as n, withWorkspaceProcessLock as t };
+export { workspaceProcessLockError as n, workspaceProcessLockPath as r, withWorkspaceProcessLock as t };