stim 1.21.0 → 1.22.0

package/dist/{metro-gateway-BMJNlj3E.mjs → metro-gateway-CKZqKqx7.mjs}

@@ -1,11 +1,108 @@
-import { p as process_identity_exports } from "./exec-_UbtCQcG.mjs";
-import { st as tailscaleStatusAsync } from "./config-CYcBF478.mjs";
-import { l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-Cjuigeeu.mjs";
-import { Qt as cancellableSleep, en as throwIfCancelled } from "./settings-CsJDEXgK.mjs";
+import { g as process_identity_exports } from "./exec-DEoAhcze.mjs";
+import { g as workspaceStateFile$1 } from "./paths-DQtTgsBf.mjs";
+import { ot as tailscaleStatusAsync } from "./config-DlrsduwG.mjs";
+import { d as cancelledError, f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, s as updateWorkspaceStateAsync } from "./workspace-state-U08dEzhG.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
+import { statSync, watch } from "node:fs";
 import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
 import { isIP } from "node:net";
+//#region src/workspace/workspace-state-watch.ts
+/** Filesystem events are hints; callers retain their own bounded repair and state verification. */
+function watchWorkspaceState(root, changed) {
+	let stopped = false;
+	let current;
+	let startup;
+	const clear = () => {
+		clearTimeout(startup);
+		const previous = current;
+		current = void 0;
+		previous?.watcher.close();
+	};
+	const refresh = () => {
+		if (stopped) return;
+		try {
+			const file = workspaceStateFile$1(root);
+			const stat = statSync(file);
+			if (current?.dev === stat.dev && current.ino === stat.ino) return;
+			clear();
+			const watcher = watch(file, { persistent: false }, () => {
+				if (stopped || current?.watcher !== watcher) return;
+				refresh();
+				changed();
+			});
+			current = {
+				watcher,
+				dev: stat.dev,
+				ino: stat.ino
+			};
+			const lost = () => {
+				if (current?.watcher === watcher) clear();
+			};
+			watcher.once("error", lost);
+			watcher.once("close", lost);
+			startup = setTimeout(() => {
+				if (stopped) return;
+				refresh();
+				changed();
+			}, 500);
+		} catch {
+			clear();
+		}
+	};
+	refresh();
+	return {
+		refresh,
+		close: () => {
+			stopped = true;
+			clear();
+		}
+	};
+}
+//#endregion
 //#region src/device-host/metro-gateway.ts
+async function waitForGateway(root, read, { waitMs, signal, what }) {
+	throwIfCancelled(signal, what);
+	const startedAt = Date.now();
+	const deadline = startedAt + waitMs;
+	let observer;
+	let timer;
+	let queued;
+	let onAbort;
+	try {
+		return await new Promise((resolve, reject) => {
+			const check = () => {
+				clearImmediate(queued);
+				queued = void 0;
+				clearTimeout(timer);
+				try {
+					throwIfCancelled(signal, what);
+					observer?.refresh();
+					const result = read();
+					const remaining = deadline - Date.now();
+					if (result !== null || remaining <= 0) resolve(result);
+					else {
+						const repairMs = Date.now() - startedAt < 500 ? 100 : 1e3;
+						timer = setTimeout(check, Math.min(remaining, repairMs));
+					}
+				} catch (error) {
+					reject(error);
+				}
+			};
+			onAbort = () => reject(cancelledError(what));
+			signal?.addEventListener("abort", onAbort, { once: true });
+			observer = watchWorkspaceState(root, () => {
+				queued ??= setImmediate(check);
+			});
+			check();
+		});
+	} finally {
+		observer?.close();
+		clearTimeout(timer);
+		clearImmediate(queued);
+		if (onAbort) signal?.removeEventListener("abort", onAbort);
+	}
+}
 function gatewayAddresses(credential, status) {
 	const machine = parseMachine(credential.machine);
 	const peer = machine ? findPeer(status, machine.name) : "missing";
@@ -46,9 +143,7 @@ async function requestHostedMetro(root, session, credential, signal) {
 			[session]: request
 		}
 	}), signal);
-	const deadline = Date.now() + 15e3;
-	while (Date.now() < deadline) {
-		throwIfCancelled(signal, "hosted Metro gateway");
+	const opened = await waitForGateway(root, () => {
 		const state = readWorkspaceState$1(root);
 		const gateway = hostedMetroGateways(state)[session];
 		if (gateway?.id === request.id && gateway.processToken === state?.supervisor?.processToken) {
@@ -58,11 +153,13 @@ async function requestHostedMetro(root, session, credential, signal) {
 				secret: request.secret
 			};
 		}
-		await cancellableSleep(100, {
-			signal,
-			what: "hosted Metro gateway"
-		});
-	}
+		return null;
+	}, {
+		waitMs: 15e3,
+		signal,
+		what: "hosted Metro gateway"
+	});
+	if (opened) return opened;
 	throw new Error(`The Metro supervisor did not open a private gateway for ${credential.machine}. Run stim stop; stim start, then retry.`);
 }
 function clearHostedMetro(root, session) {
@@ -75,18 +172,19 @@ function clearHostedMetro(root, session) {
 		};
 	});
 }
-async function closeHostedMetro(root, session) {
-	await withWorkspaceStateLockAsync(root, () => clearHostedMetro(root, session));
-	const deadline = Date.now() + 5e3;
-	while (true) {
+async function closeHostedMetro(root, session, signal) {
+	await withWorkspaceStateLockAsync(root, () => clearHostedMetro(root, session), signal);
+	if (!await waitForGateway(root, () => {
 		const state = readWorkspaceState$1(root);
 		const gateway = hostedMetroGateways(state)[session];
 		const supervisor = state?.supervisor;
-		if (!gateway?.port || !supervisor || gateway.processToken !== supervisor.processToken) return;
-		if ((0, process_identity_exports.inspectProcessIdentity)(supervisor) === "gone") return;
-		if (Date.now() >= deadline) throw new Error("The Metro supervisor did not close its private gateway. Restart Metro, then retry stim stop.");
-		await new Promise((done) => setTimeout(done, 100));
-	}
+		if (!gateway?.port || !supervisor || gateway.processToken !== supervisor.processToken) return true;
+		return (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "gone" ? true : null;
+	}, {
+		waitMs: 5e3,
+		signal,
+		what: "close hosted Metro"
+	})) throw new Error("The Metro supervisor did not close its private gateway. Restart Metro, then retry stim stop.");
 }
 function hostedMetroSettings(settings, hosted) {
 	return hosted ? {
@@ -108,4 +206,4 @@ function hostedMetroSettings(settings, hosted) {
 	} : settings;
 }
 //#endregion
-export { requireHostedMetro as a, requestHostedMetro as i, closeHostedMetro as n, hostedMetroSettings as r, clearHostedMetro as t };
+export { requireHostedMetro as a, requestHostedMetro as i, closeHostedMetro as n, watchWorkspaceState as o, hostedMetroSettings as r, clearHostedMetro as t };

package/dist/{named-ports-BWTzt6mu.mjs → named-ports-DkEzOfzO.mjs}

@@ -1,7 +1,6 @@
-import { p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
-import { C as saveConfig, O as withConfigLockAsync, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-CYcBF478.mjs";
-import { c as parseNetstatPids, h as createPortProbe, p as signalProcessTree } from "./metro-DEXpIhHC.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
+import { g as process_identity_exports, i as withWorkspaceProcessLock, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { C as saveConfig, O as withConfigLockAsync, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-DlrsduwG.mjs";
+import { f as signalProcessTree, m as createPortProbe, s as parseNetstatPids } from "./metro-DiXtA3Ty.mjs";
 import { realpathSync } from "node:fs";
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;
@@ -57,8 +56,11 @@ function processCommand(pid, platform) {
 		"args="
 	], { timeoutMs: 5e3 }) ?? "").trim();
 }
-function withPortsLock(fn) {
-	return withWorkspaceProcessLock(getConfigDir(), "ports", fn, { external: true });
+function withPortsLock(fn, signal) {
+	return withWorkspaceProcessLock(getConfigDir(), "ports", fn, {
+		external: true,
+		signal
+	});
 }
 async function getNamedPort(projectPath, label, options = {}) {
 	validatePortLabel(label);
@@ -68,14 +70,14 @@ async function getNamedPort(projectPath, label, options = {}) {
 function reserveBrowserPort(projectPath, options = {}) {
 	return allocateNamedPort(projectPath, BROWSER_LABEL, options);
 }
-function releaseBrowserPort(projectPath, port) {
-	return withPortsLock(async () => withConfigLockAsync(() => {
+function releaseBrowserPort(projectPath, port, signal) {
+	return withPortsLock(() => withConfigLockAsync(() => {
 		const cfg = loadConfig();
 		const ports = cfg?.projects?.[projectPath]?.ports;
 		if (!cfg || ports?.[BROWSER_LABEL] !== port) return;
 		delete ports[BROWSER_LABEL];
 		saveConfig(cfg);
-	}));
+	}, signal), signal);
 }
 async function allocateNamedPort(projectPath, label, { isFree = createPortProbe() }) {
 	const root = realpathSync(projectPath);
@@ -103,9 +105,10 @@ async function allocateNamedPort(projectPath, label, { isFree = createPortProbe(
 		throw new Error(`No free named port between ${FIRST_PORT} and ${LAST_PORT}. Use stim ports stop or stim ports release in a workspace that no longer needs its ports.`);
 	});
 }
-async function stopListeners(port, label, dryRun, log, platform) {
+async function stopListeners(port, label, dryRun, log, platform, signal) {
 	const listeners = () => portListeners(port, platform);
 	for (const pid of listeners()) {
+		signal?.throwIfAborted();
 		if (pid === process.pid) throw new Error(`Refusing to stop Stim itself on ${label} (${port}).`);
 		const identity = (0, process_identity_exports.captureProcessIdentity)(pid);
 		if (!identity.ok) {
@@ -127,10 +130,10 @@ async function stopListeners(port, label, dryRun, log, platform) {
 		if (status !== "same") throw new Error(`Cannot verify pid ${pid} on ${label} (${port}); allocation kept.`);
 		try {
 			signalProcessTree(pid, "SIGTERM", { platform });
-			if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) {
+			if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3, signal)) {
 				if ((0, process_identity_exports.inspectProcessIdentity)(record) !== "same") throw new Error(`Cannot verify pid ${pid} before SIGKILL.`);
 				signalProcessTree(pid, "SIGKILL", { platform });
-				if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) throw new Error(`Pid ${pid} did not exit.`);
+				if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3, signal)) throw new Error(`Pid ${pid} did not exit.`);
 			}
 		} catch (error) {
 			if (error.code !== "ESRCH") throw error;
@@ -139,36 +142,40 @@ async function stopListeners(port, label, dryRun, log, platform) {
 	}
 	if (!dryRun && listeners().length) throw new Error(`Port ${port} still has a listener; allocation kept.`);
 }
-async function clearNamedPorts(projectPath, { label, stop = false, dryRun = false, log = console.error, platform = process.platform } = {}) {
+async function clearNamedPorts(projectPath, { label, stop = false, dryRun = false, log = console.error, platform = process.platform, signal } = {}) {
 	if (label !== void 0) validatePortLabel(label);
 	await withPortsLock(async () => {
 		const ports = getProject(projectPath)?.ports ?? {};
 		const selected = Object.entries(ports).filter(([name]) => name !== BROWSER_LABEL && (label === void 0 || name === label));
 		if (stop && selected.length > 0 && platform !== "win32" && !getExecutor().findExecutable("lsof")) throw new Error("Cannot stop named ports: lsof is not installed.");
 		const failures = [];
-		for (const [name, port] of selected) try {
-			if (!Number.isInteger(port) || port < FIRST_PORT || port > LAST_PORT) throw new Error(`Invalid named port ${name} (${port}); repair its config record before cleanup.`);
-			if (stop) {
-				if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port)) throw new Error(`Port ${port} is reserved for managed Metro; allocation kept.`);
-				await stopListeners(port, name, dryRun, log, platform);
-			}
-			if (dryRun) {
-				log(`would release ${name} (${port})`);
-				continue;
+		for (const [name, port] of selected) {
+			signal?.throwIfAborted();
+			try {
+				if (!Number.isInteger(port) || port < FIRST_PORT || port > LAST_PORT) throw new Error(`Invalid named port ${name} (${port}); repair its config record before cleanup.`);
+				if (stop) {
+					if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port)) throw new Error(`Port ${port} is reserved for managed Metro; allocation kept.`);
+					await stopListeners(port, name, dryRun, log, platform, signal);
+				}
+				if (dryRun) {
+					log(`would release ${name} (${port})`);
+					continue;
+				}
+				await withConfigLockAsync(() => {
+					const cfg = loadConfig();
+					const current = cfg?.projects?.[projectPath]?.ports;
+					if (!cfg || current?.[name] !== port) return;
+					delete current[name];
+					saveConfig(cfg);
+				}, signal);
+				log(`released ${name} (${port})`);
+			} catch (error) {
+				signal?.throwIfAborted();
+				failures.push(`${name} (${port}): ${error.message}`);
 			}
-			await withConfigLockAsync(() => {
-				const cfg = loadConfig();
-				const current = cfg?.projects?.[projectPath]?.ports;
-				if (!cfg || current?.[name] !== port) return;
-				delete current[name];
-				saveConfig(cfg);
-			});
-			log(`released ${name} (${port})`);
-		} catch (error) {
-			failures.push(`${name} (${port}): ${error.message}`);
 		}
 		if (failures.length) throw new Error(failures.join("\n"));
-	});
+	}, signal);
 }
 //#endregion
 export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };