stim 1.14.0 → 1.16.0

package/dist/maintenance-run.mjs

@@ -0,0 +1,254 @@
+import { j as formatBytes } from "./config-D0DbpZtM.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
+import { s as resolveBudget } from "./budget-DjrURfQn.mjs";
+import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
+import { r as due, t as capChildLog } from "./attempt-Bk2ouQVL.mjs";
+import { a as sizeScanDeferred, i as measureSizes, r as measurePressure, t as plannedMaintenance } from "./preview-DhVbvPAZ.mjs";
+import { appendFileSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { LOG_ROTATE_BYTES, rotatedLogPath, withDirLock } from "@stim-cli/core";
+import { maintenanceChildLogFile, maintenanceDir, maintenanceNdjsonFile, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState, workspaceLogsDir } from "@stim-cli/core/state";
+import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
+import { fileURLToPath } from "node:url";
+//#region src/maintenance/log.ts
+function maintenanceLogger(settings, pass, trigger) {
+	const file = maintenanceNdjsonFile();
+	const rotated = rotatedLogPath(file);
+	withDirLock(`${file}.lock`, () => {
+		try {
+			if (Date.now() - statSync(rotated).mtimeMs > settings.logRetentionDays * 864e5) unlinkSync(rotated);
+		} catch {}
+	});
+	const writer = createNdjsonWriter(file, { maxBytes: settings.logMaxMb * 1024 ** 2 });
+	return {
+		write(event, level, msg, fields = {}) {
+			if (level === "debug" && !settings.logChecks) return null;
+			const record = {
+				...fields,
+				ts: Date.now(),
+				src: "maintenance",
+				level,
+				msg,
+				event,
+				pass,
+				trigger,
+				mode: "report"
+			};
+			if (!writer.write(record)) throw writer.lastError ?? /* @__PURE__ */ new Error(`Could not append ${file}`);
+			if (typeof fields.workspace === "string" && [
+				"maintenance_action",
+				"maintenance_failure",
+				"maintenance_skip"
+			].includes(event)) {
+				const workspace = createNdjsonWriter(join(workspaceLogsDir(fields.workspace), "maintenance.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+				try {
+					if (!workspace.write(record)) throw workspace.lastError ?? /* @__PURE__ */ new Error("Could not append workspace maintenance log");
+				} finally {
+					workspace.close();
+				}
+			}
+			return record;
+		},
+		close: () => writer.close()
+	};
+}
+//#endregion
+//#region src/maintenance/run.ts
+function writeState(state) {
+	mkdirSync(maintenanceDir(), { recursive: true });
+	withDirLock(join(maintenanceDir(), "state.lock"), () => {
+		const file = maintenanceStateFile();
+		const tmp = `${file}.${process.pid}.tmp`;
+		writeFileSync(tmp, `${JSON.stringify(state)}\n`);
+		try {
+			renameSync(tmp, file);
+		} finally {
+			try {
+				unlinkSync(tmp);
+			} catch {}
+		}
+	});
+}
+const actionKey = (action) => JSON.stringify([action.kind, action.target]);
+const stableText = (text) => text.replace(/\d+(?:\.\d+)?/g, "#");
+const sameSet = (before, after) => before.size === after.size && [...before].every((key) => after.has(key));
+async function runMaintenance(trigger) {
+	const startedAt = Date.now();
+	let claim;
+	try {
+		const attempt = tryAcquireClaim({
+			root: maintenanceRunClaims(),
+			mode: "exclusive",
+			label: "maintenance",
+			details: { trigger }
+		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		claim = attempt.acquired;
+	} catch (error) {
+		crashLine(error);
+		return;
+	}
+	if (!claim) return;
+	let logger;
+	try {
+		const settings = resolveMaintenanceSettings();
+		if (settings.mode === "off") return;
+		const state = readMaintenanceState() ?? {
+			version: 1,
+			lastAt: {},
+			pressure: null,
+			sizes: [],
+			lastPass: null,
+			recent: [],
+			plan: []
+		};
+		const checks = due(state, settings, startedAt);
+		if (checks.length === 0) return;
+		logger = maintenanceLogger(settings, `p-${claim.claimId}`, trigger);
+		const record = (event, level, msg, fields = {}) => {
+			const entry = logger.write(event, level, msg, fields);
+			if (entry && (event === "maintenance_action" || event === "maintenance_failure" || Array.isArray(fields.blocked) && fields.blocked.length > 0)) state.recent = [...state.recent, entry].slice(-20);
+		};
+		const failures = [];
+		let measuredSizes = false;
+		const budget = resolveBudget().budget;
+		for (const check of checks) {
+			if (check === "size" && sizeScanDeferred(settings)) {
+				record("maintenance_skip", "debug", "Size check deferred: host load exceeds maintenance.maxLoadPerCore", {
+					target: "size",
+					reason: "host load exceeds maintenance.maxLoadPerCore"
+				});
+				state.deferredAt = {
+					...state.deferredAt,
+					[check]: Date.now()
+				};
+				writeState(state);
+				continue;
+			}
+			state.lastAt[check] = Date.now();
+			delete state.deferredAt?.[check];
+			writeState(state);
+			try {
+				if (check === "pressure") {
+					state.pressure = measurePressure(settings, state.pressure, state.lastAt[check]);
+					const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+					for (const disk of state.pressure.disk) record("maintenance_check", "debug", `Disk free on ${disk.volume}: ${(disk.freeMb / 1024).toFixed(1)}G`, { check: {
+						kind: "disk-free",
+						value: disk.freeMb / 1024,
+						threshold: floor / 1024,
+						unit: "GiB"
+					} });
+					record("maintenance_check", "debug", `Memory pressure: ${state.pressure.memory.level ?? "unavailable"}`, { check: {
+						kind: state.pressure.memory.availableBytes === null ? "memory-pressure" : "memory-available",
+						value: state.pressure.memory.availableBytes === null ? state.pressure.memory.level : state.pressure.memory.availableBytes / 1024 ** 3,
+						threshold: state.pressure.memory.availableBytes === null ? settings.memoryPressureLevel : settings.minAvailableMemoryGb ?? "10% of RAM",
+						unit: state.pressure.memory.availableBytes === null ? "level" : "GiB"
+					} });
+				} else {
+					measuredSizes = true;
+					state.sizes = measureSizes(state.lastAt[check], (target, workspace) => {
+						failures.push(`Could not measure ${target}`);
+						record("maintenance_failure", "error", `Could not measure ${target}`, {
+							target,
+							error: "du failed or timed out",
+							...workspace ? { workspace } : {}
+						});
+					});
+					for (const size of state.sizes) record("maintenance_check", "debug", `${size.name}: ${formatBytes(size.bytes)}`, {
+						check: {
+							kind: `size:${size.category}`,
+							value: size.bytes,
+							unit: "bytes"
+						},
+						target: size.dir
+					});
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				failures.push(message);
+				record("maintenance_failure", "error", `${check} check failed: ${message}`, {
+					target: check,
+					error: message
+				});
+			}
+		}
+		let result;
+		try {
+			result = await plannedMaintenance(state.pressure, state.sizes, settings);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			failures.push(message);
+			record("maintenance_failure", "error", `Could not plan maintenance: ${message}`, {
+				target: "plan",
+				error: message
+			});
+			result = {
+				actions: [],
+				blocked: [],
+				skips: []
+			};
+		}
+		const previousActions = new Set(state.plan.map(actionKey));
+		const nextActions = new Set(result.actions.map(actionKey));
+		const previousSkips = new Set(state.skipKeys ?? []);
+		const nextSkips = new Set(result.skips.map((skip) => skip.target));
+		const blocked = [...result.blocked, ...failures];
+		const changed = !state.lastPass || !sameSet(previousActions, nextActions) || !sameSet(previousSkips, nextSkips) || !sameSet(new Set(state.lastPass.blocked.map(stableText)), new Set(blocked.map(stableText)));
+		for (const action of result.actions) {
+			if (previousActions.has(actionKey(action))) continue;
+			previousActions.add(actionKey(action));
+			record("maintenance_action", "info", `Would ${action.kind === "would-clear-outputs" ? `clear build outputs of ${basename(action.workspace ?? action.target)}` : `${action.kind.slice(6).replaceAll("-", " ")} ${action.target}`} (${formatBytes(action.bytes)}): ${action.reason}`, {
+				action: {
+					...action,
+					durationMs: 0
+				},
+				...action.workspace ? { workspace: action.workspace } : {}
+			});
+		}
+		for (const skip of result.skips) {
+			if (previousSkips.has(skip.target)) continue;
+			previousSkips.add(skip.target);
+			record("maintenance_skip", "info", `Kept ${skip.target}: ${skip.reason}`, skip);
+		}
+		state.plan = result.actions;
+		state.skipKeys = [...nextSkips];
+		state.lastPass = {
+			startedAt,
+			durationMs: Date.now() - startedAt,
+			trigger,
+			mode: "report",
+			freedBytes: 0,
+			actions: result.actions.length,
+			stopped: 0,
+			blocked
+		};
+		if (measuredSizes || changed) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Report-only pass: ${result.actions.length} planned actions${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
+		writeState(state);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		try {
+			logger?.write("maintenance_failure", "error", `Maintenance failed: ${message}`, {
+				target: "pass",
+				error: message
+			});
+		} catch {}
+		crashLine(error);
+	} finally {
+		logger?.close();
+		releaseClaim(claim);
+	}
+}
+function crashLine(error) {
+	try {
+		mkdirSync(maintenanceDir(), { recursive: true });
+		const file = maintenanceChildLogFile();
+		capChildLog();
+		appendFileSync(file, `${String(error).replaceAll("\n", " ")}\n`);
+	} catch {}
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+	if (!relaunchWithLogFile(process.argv.slice(2))) await runMaintenance(process.argv[2] ?? "command");
+}
+//#endregion
+export { runMaintenance };

package/dist/{metro-CcEo8Fl8.mjs → metro-BeK1ZPz1.mjs}

@@ -1,116 +1,11 @@
-import { N as isOnMountedVolume, O as process_identity_exports, P as listMountedVolumes, _ as loadConfig$1, b as releaseMetroPort, n as allMetroPorts, r as claimMetroPort } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { existsSync as existsSync$1, readlinkSync as readlinkSync$1, realpathSync as realpathSync$1 } from "fs";
-import { join, resolve, sep } from "path";
-import { buildCacheRoot as sharedBuildCache, withDirLock, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
-import { emulatorLogFile, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache, sharedCompilationCache, supervisorLogFile, supervisorPidFile, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
-import { dirname as dirname$1 } from "node:path";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as readWorkspaceState } from "./workspace-state-B8-aJ1_5.mjs";
+import { existsSync, readlinkSync, realpathSync } from "fs";
+import { sep } from "path";
 import { request } from "http";
 import { connect } from "net";
-//#region src/workspace/paths.ts
-function ensureWorkspaceStorage(projectRoot) {
-	const canonicalRoot = resolve(projectRoot);
-	const dir = workspaceDir(canonicalRoot);
-	const file = workspaceMetadataFile(canonicalRoot);
-	mkdirSync(dir, { recursive: true });
-	return withDirLock(join(dir, "metadata.lock"), () => {
-		if (!existsSync(file)) {
-			const metadata = {
-				projectRoot: canonicalRoot,
-				workspace: workspaceName$1(canonicalRoot),
-				version: 1
-			};
-			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
-			try {
-				renameSync(tmp, file);
-			} catch (error) {
-				rmSync(tmp, { force: true });
-				throw error;
-			}
-			return dir;
-		}
-		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
-		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
-		error.code = "STIM_WORKSPACE_COLLISION";
-		throw error;
-	});
-}
-//#endregion
-//#region src/workspace/workspace-state.ts
-function withWorkspaceStateLock(root, fn) {
-	const file = workspaceStateFile(root);
-	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
-		ensureWorkspaceStorage(root);
-		mkdirSync(dirname$1(file), { recursive: true });
-	} });
-}
-function writeWorkspaceState(root, patch) {
-	return updateWorkspaceState(root, (state) => ({
-		...state,
-		...patch
-	}));
-}
-function updateWorkspaceState(root, update) {
-	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
-}
-function replaceWorkspaceState(root, state) {
-	const file = workspaceStateFile(root);
-	mkdirSync(dirname$1(file), { recursive: true });
-	const tmp = `${file}.tmp-${process.pid}`;
-	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
-	renameSync(tmp, file);
-	return state;
-}
-function clearWorkspaceStateKeys(root, keys) {
-	if (!existsSync(workspaceStateFile(root))) return;
-	withWorkspaceStateLock(root, () => {
-		const state = readWorkspaceState(root);
-		const file = workspaceStateFile(root);
-		if (!state) {
-			try {
-				rmSync(file, { force: true });
-			} catch {}
-			return;
-		}
-		let changed = false;
-		for (const key of keys) {
-			if (!(key in state)) continue;
-			delete state[key];
-			changed = true;
-		}
-		if (!changed) return;
-		if (Object.keys(state).length === 0) {
-			rmSync(file, { force: true });
-			return;
-		}
-		replaceWorkspaceState(root, state);
-	});
-}
-function clearWorkspaceStateKey(root, key, shouldClear) {
-	return withWorkspaceStateLock(root, () => {
-		const state = readWorkspaceState(root);
-		if (!state || !(key in state)) return true;
-		if (!shouldClear(state[key])) return false;
-		delete state[key];
-		const file = workspaceStateFile(root);
-		if (Object.keys(state).length === 0) {
-			try {
-				rmSync(file, { force: true });
-			} catch {}
-			return true;
-		}
-		replaceWorkspaceState(root, state);
-		return true;
-	});
-}
-function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date()) {
-	try {
-		writeWorkspaceState(root, { lastUsedAt: now.toISOString() });
-	} catch {}
-}
-//#endregion
 //#region src/ports.ts
 function isMetroRunning(port) {
 	return new Promise((resolve) => {
@@ -161,14 +56,14 @@ async function computeNextPort(isFree = isPortFree) {
 	throw new Error(`Found no free Metro port between ${FIRST_PORT} and 8281. Free one up, or stop a stale bundler (\`stim status\`, \`stim stop <port>\`).`);
 }
 async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, { isMounted = isOnMountedVolume, mountedVolumes } = {}) {
-	const cfg = loadConfig$1();
+	const cfg = loadConfig();
 	if (!cfg?.projects) return null;
 	const mounted = mountedVolumes || listMountedVolumes();
 	const candidates = [];
 	for (const [path, proj] of Object.entries(cfg.projects)) {
 		if (path === excludeProjectPath) continue;
 		if (Object.keys(proj.ports ?? {}).length) continue;
-		if (existsSync$1(path)) continue;
+		if (existsSync(path)) continue;
 		if (!isMounted(path, mounted)) continue;
 		if (typeof proj.metroPort === "number") candidates.push({
 			port: proj.metroPort,
@@ -187,7 +82,11 @@ async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPort
 	return computeNextPort(isFree);
 }
 const RESERVE_ATTEMPTS = 5;
-async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree, pinned = null) {
+	if (pinned !== null) {
+		if (claimMetroPort(projectPath, pinned) !== null) return pinned;
+		throw new Error(`metro.port ${pinned} is already reserved by another workspace's Metro or named port.`);
+	}
 	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
 		const port = await allocatePort(projectPath, probe, isFree);
 		const claimed = claimMetroPort(projectPath, port);
@@ -296,7 +195,7 @@ async function processCwds(pids) {
 	for (const pid of new Set(pids)) {
 		let cwd = null;
 		if (process.platform === "linux") try {
-			cwd = readlinkSync$1(`/proc/${pid}/cwd`);
+			cwd = readlinkSync(`/proc/${pid}/cwd`);
 		} catch {}
 		if (cwd) cwds.set(pid, cwd);
 		else viaLsof.push(pid);
@@ -317,13 +216,13 @@ async function processCwds(pids) {
 }
 function processCwd(pid) {
 	if (process.platform === "linux") try {
-		return readlinkSync$1(`/proc/${pid}/cwd`);
+		return readlinkSync(`/proc/${pid}/cwd`);
 	} catch {}
 	return parseLsofCwd(getExecutor().runQuiet(`lsof -a -p ${pid} -d cwd -Fn`));
 }
 function canonicalPath(path) {
 	try {
-		return realpathSync$1(path);
+		return realpathSync(path);
 	} catch {
 		return path;
 	}
@@ -338,7 +237,7 @@ const NOT_OURS_UNRESPONSIVE = "unresponsive";
 const NOT_OURS_UNREADABLE_CWD = "unreadable-cwd";
 const NOT_OURS_FOREIGN_CWD = "foreign-cwd";
 function ownedSupervisor(projectPath, port) {
-	const supervisor = readWorkspaceState$1(canonicalPath(projectPath))?.supervisor;
+	const supervisor = readWorkspaceState(canonicalPath(projectPath))?.supervisor;
 	if (supervisor?.port !== port || (0, process_identity_exports.inspectProcessIdentity)(supervisor) !== "same") return null;
 	return supervisor;
 }
@@ -368,7 +267,8 @@ async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning,
 	if (!isInsideProject(cwd, projectPath)) return {
 		notOurs: `pid ${pid} on port ${port} runs from ${cwd}, outside ${projectPath}`,
 		kind: NOT_OURS_FOREIGN_CWD,
-		pid
+		pid,
+		cwd
 	};
 	const owner = ownedSupervisor(projectPath, port);
 	return { metro: {
@@ -406,4 +306,4 @@ function killMetroTree(leader, processToken) {
 	}
 }
 //#endregion
-export { workspaceId as A, sharedBuildCache as C, supervisorPidFile as D, supervisorLogFile as E, withDirLock as F, workspaceLogsDir as M, workspaceName$1 as N, workspaceDerivedData as O, workspaceStateFile as P, ensureWorkspaceStorage as S, sharedCompilationCache as T, updateWorkspaceState as _, pidExists as a, writeWorkspaceState as b, resolveProjectMetro as c, isPortFree as d, reserveMetroPort as f, recordWorkspaceUse as g, readWorkspaceState$1 as h, listeningPidsByPort as i, workspaceLogErrorIndex as j, workspaceDir as k, signalProcessTree as l, clearWorkspaceStateKeys as m, killMetroTree as n, processCwd as o, clearWorkspaceStateKey as p, listeningPids as r, processCwds as s, NOT_OURS_FOREIGN_CWD as t, isMetroRunning as u, withWorkspaceStateLock as v, sharedCcache as w, emulatorLogFile as x, workspaceLastUsed as y };
+export { listeningPidsByPort as a, processCwds as c, isMetroRunning as d, isPortFree as f, listeningPids as i, resolveProjectMetro as l, isInsideProject as n, pidExists as o, reserveMetroPort as p, killMetroTree as r, processCwd as s, NOT_OURS_FOREIGN_CWD as t, signalProcessTree as u };

package/dist/metro-gateway-BJ-rxQAB.mjs

@@ -0,0 +1,84 @@
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { b as realIo } from "./client-BTY686R6.mjs";
+import { randomBytes, randomUUID } from "node:crypto";
+import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
+import { isIP } from "node:net";
+//#region src/device-host/metro-gateway.ts
+function gatewayAddresses(credential, status) {
+	const machine = parseMachine(credential.machine);
+	const peer = machine ? findPeer(status, machine.name) : "missing";
+	if (typeof peer === "string" || peer.nodeId !== credential.nodeId) throw new Error(`${credential.machine} no longer resolves to its pinned tailnet node. Run stim doctor.`);
+	const self = isJsonObject(status) && isJsonObject(status.Self) ? status.Self : null;
+	const address = (Array.isArray(self?.TailscaleIPs) ? self.TailscaleIPs : []).find((ip) => typeof ip === "string" && isIP(ip) === isIP(peer.address) && isIP(ip) !== 0);
+	if (!address) throw new Error("This Mac has no Tailscale address compatible with the hosting Mac.");
+	return {
+		address,
+		peer: peer.address
+	};
+}
+function requireHostedMetro(root) {
+	const supervisor = readWorkspaceState$1(root)?.supervisor;
+	if (supervisor?.hostedMetro === true && (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "same") return;
+	throw Object.assign(/* @__PURE__ */ new Error("Hosted Debug runs require a running Metro supervisor with private gateway support. Run stim stop; stim start, then retry."), {
+		code: "STIM_HOSTING_REFUSED",
+		remedy: "Run stim stop; stim start, then retry."
+	});
+}
+async function requestHostedMetro(root, session, credential) {
+	requireHostedMetro(root);
+	const addresses = gatewayAddresses(credential, realIo.status());
+	const previous = hostedMetroRequests(readWorkspaceState$1(root))[session];
+	const request = previous && previous.address === addresses.address && previous.peer === addresses.peer ? previous : {
+		id: randomUUID(),
+		machine: credential.machine,
+		...addresses,
+		secret: randomBytes(32).toString("hex")
+	};
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[HOSTED_METRO_REQUESTS_KEY]: {
+			...hostedMetroRequests(state),
+			[session]: request
+		}
+	}));
+	const deadline = Date.now() + 15e3;
+	while (Date.now() < deadline) {
+		const state = readWorkspaceState$1(root);
+		const gateway = hostedMetroGateways(state)[session];
+		if (gateway?.id === request.id && gateway.processToken === state?.supervisor?.processToken) {
+			if (gateway.error) throw new Error(gateway.error);
+			if (gateway.port) return {
+				gatewayPort: gateway.port,
+				secret: request.secret
+			};
+		}
+		await new Promise((done) => setTimeout(done, 100));
+	}
+	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) {
+	updateWorkspaceState(root, (state) => {
+		const requests = { ...hostedMetroRequests(state) };
+		delete requests[session];
+		return {
+			...state,
+			[HOSTED_METRO_REQUESTS_KEY]: requests
+		};
+	});
+}
+async function closeHostedMetro(root, session) {
+	clearHostedMetro(root, session);
+	const deadline = Date.now() + 5e3;
+	while (true) {
+		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));
+	}
+}
+//#endregion
+export { requireHostedMetro as i, closeHostedMetro as n, requestHostedMetro as r, clearHostedMetro as t };

package/dist/{named-ports-Blg8IxOh.mjs → named-ports-Bk_YXEmE.mjs}

@@ -1,62 +1,9 @@
-import { A as ownership_claim_exports, E as withConfigLock, O as process_identity_exports, S as saveConfig, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { d as isPortFree, l as signalProcessTree, r as listeningPids } from "./metro-CcEo8Fl8.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Drw_o-Fb.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-BeK1ZPz1.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
 import { realpathSync } from "node:fs";
-import { join } from "node:path";
-//#region src/engine/workspace-process-lock.ts
-const DEFAULT_WAIT_MS = 6e4;
-const POLL_MS = 25;
-const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-function workspaceProcessLockError(err) {
-	const code = err?.code;
-	if (code === "STIM_LOCK_REFUSED") return "refused";
-	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
-	return null;
-}
-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, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
-	const path = workspaceProcessLockPath(root, name, external);
-	const deadline = now() + waitMs;
-	for (;;) {
-		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-			root: path,
-			mode: "exclusive",
-			label: `${name} lock`,
-			details: ownerPurpose ? {
-				...details,
-				purpose: ownerPurpose
-			} : details
-		});
-		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		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 holder = attempt.held ?? attempt.waitingFor?.[0];
-		const purpose = holder?.details.purpose;
-		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
-			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
-			error.code = "STIM_LOCK_REFUSED";
-			throw error;
-		}
-		if (holder && onHeld) await onHeld(holder);
-		if (now() >= deadline) {
-			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
-			error.code = "STIM_LOCK_TIMEOUT";
-			throw error;
-		}
-		await sleep(POLL_MS);
-	}
-}
-//#endregion
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;
 const LAST_PORT = 8999;
@@ -218,4 +165,4 @@ async function clearNamedPorts(projectPath, { label, stop = false, dryRun = fals
 	});
 }
 //#endregion
-export { withWorkspaceProcessLock as a, reserveBrowserPort as i, getNamedPort as n, workspaceProcessLockError as o, releaseBrowserPort as r, workspaceProcessLockPath as s, clearNamedPorts as t };
+export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };