stim 0.0.0 → 1.1.0

package/dist/supervisor-run.mjs

@@ -0,0 +1,210 @@
+import { T as captureProcessToken, a as clearSupervisor, x as setSupervisor } from "./config-D7uu8Gbq.mjs";
+import { r as createNdjsonWriter } from "./ndjson-DcAtEx_K.mjs";
+import { D as workspaceLogsDir, _ as writeWorkspaceState, h as writePidFile, l as readPidFile, m as withWorkspaceStateLock, n as MODE_EXPO, p as readWorkspaceState, r as clearExpoMetroTunnel, s as clearWorkspaceSupervisor, t as MODE_BARE } from "./state-IYEY-zi8.mjs";
+import { i as detectIsExpo } from "./project-COj6nzzh.mjs";
+import { t as describeError } from "./errors-B6W7FkxQ.mjs";
+import { existsSync, realpathSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/supervisor/run.ts
+function parseArgs(argv) {
+	let root;
+	let port;
+	let tunnel = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--root") {
+			root = argv[++i];
+			continue;
+		}
+		if (arg === "--port") {
+			port = argv[++i];
+			continue;
+		}
+		if (arg === "--tunnel") {
+			tunnel = true;
+			continue;
+		}
+		return { error: `Unknown supervisor argument "${arg}". Usage: run.js --root <path> --port <n> [--tunnel]` };
+	}
+	if (!root) return { error: "Missing --root. Usage: run.js --root <path> --port <n> [--tunnel]" };
+	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}".` };
+	return {
+		root: resolve(root),
+		port: parsedPort,
+		tunnel
+	};
+}
+async function runSupervisor({ root, port, tunnel = false, 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 mode = isExpo(root) ? MODE_EXPO : MODE_BARE;
+	const startedAt = new Date(now()).toISOString();
+	const processToken = captureProcessToken(process.pid);
+	if (!processToken) {
+		stderr("Stim supervisor: could not capture process identity; refusing to start an unmanaged server.");
+		writer.close();
+		onExit(1);
+		return null;
+	}
+	const record = {
+		pid: process.pid,
+		processToken,
+		port,
+		mode,
+		startedAt
+	};
+	clearExpoMetroTunnel(root);
+	writePidFile(root, process.pid);
+	writeWorkspaceState(root, { supervisor: record });
+	try {
+		setSupervisor(root, record);
+	} catch (err) {
+		writer.write({
+			src: "metro",
+			level: "warn",
+			event: "supervisor_registration_failed",
+			msg: `Could not record the supervisor in the global config: ${describeError(err)}`
+		});
+		stderr(`Stim supervisor: global registration failed: ${describeError(err)}`);
+	}
+	writer.write({
+		src: "metro",
+		level: "info",
+		event: "supervisor_started",
+		msg: `supervisor pid ${process.pid} starting the ${mode} dev server on port ${port} for ${root}`
+	});
+	let stopping = false;
+	const finish = (code, event, level, msg) => {
+		writer.write({
+			src: "metro",
+			level,
+			event,
+			msg
+		});
+		try {
+			clearSupervisor(root, record);
+		} catch {}
+		try {
+			clearWorkspaceSupervisor(root, record);
+		} catch {}
+		const closed = writer.close();
+		if (closed.dropped > 0) stderr(`Stim supervisor: dropped ${closed.dropped} log record(s); last error: ${describeError(closed.lastError)}`);
+		onExit(code);
+	};
+	let server;
+	try {
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-rb0k-0w7.mjs")).startExpoServer : startBare || (await import("./server-bare-BYHqEeyw.mjs")).startBareServer)({
+			root,
+			port,
+			logsDir,
+			writer,
+			tunnel,
+			onTunnelUrl: (url) => {
+				try {
+					withWorkspaceStateLock(root, () => {
+						if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { metroTunnel: {
+							kind: "expo",
+							url
+						} });
+					});
+				} catch (err) {
+					stderr(`Stim supervisor: could not record the Expo tunnel URL: ${describeError(err)}`);
+				}
+				writer.write({
+					src: "metro",
+					level: "info",
+					event: "expo_tunnel_ready",
+					msg: `Expo tunnel ready: ${url}`
+				});
+			}
+		});
+	} catch (err) {
+		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
+		} });
+	});
+	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)
+			});
+		}
+		finish(code, event, code === 0 ? "info" : "error", msg);
+	};
+	readyServer.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,
+		shutdown,
+		startedAt
+	};
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsed = parseArgs(argv);
+	if (parsed.error) {
+		console.error(`Stim supervisor: ${parsed.error}`);
+		process.exit(2);
+		return;
+	}
+	const root = parsed.root;
+	if (!existsSync(root)) {
+		console.error(`Stim supervisor: --root ${root} does not exist.`);
+		process.exit(2);
+		return;
+	}
+	try {
+		process.chdir(root);
+	} catch {}
+	process.title = "stim-supervisor";
+	await runSupervisor({
+		root,
+		port: parsed.port,
+		tunnel: parsed.tunnel ?? false
+	});
+}
+function invokedDirectly() {
+	const entry = process.argv[1];
+	if (!entry) return false;
+	try {
+		return resolve(entry) === fileURLToPath(import.meta.url);
+	} catch {
+		return false;
+	}
+}
+if (invokedDirectly()) main().catch((err) => {
+	console.error(`Stim supervisor: ${describeError(err)}`);
+	process.exit(1);
+});
+//#endregion
+export { MODE_BARE, MODE_EXPO, clearExpoMetroTunnel, clearWorkspaceSupervisor, main, parseArgs, readPidFile, readWorkspaceState, runSupervisor, withWorkspaceStateLock, writePidFile, writeWorkspaceState };

package/dist/workspace-process-lock-CxOO9-pf.mjs

@@ -0,0 +1,47 @@
+import { f as releaseClaim, h as tryAcquireClaim } from "./ownership-claim-CeJLEpjD.mjs";
+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 lockPath(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);
+	const deadline = now() + waitMs;
+	for (;;) {
+		const attempt = tryAcquireClaim({
+			root: path,
+			mode: "exclusive",
+			label: `${name} lock`,
+			details: ownerPurpose ? { purpose: ownerPurpose } : {}
+		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		if (attempt.acquired) try {
+			return await fn();
+		} finally {
+			releaseClaim(attempt.acquired);
+		}
+		const purpose = (attempt.held ?? attempt.waitingFor?.[0])?.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 (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
+export { workspaceProcessLockError as n, withWorkspaceProcessLock as t };