stim 1.8.0 → 1.10.0

package/dist/metro-BWLOJ_Wr.mjs

@@ -0,0 +1,409 @@
+import { D as process_identity_exports, M as isOnMountedVolume, N as listMountedVolumes, g as loadConfig$1, n as allMetroPorts, r as claimMetroPort, y as releaseMetroPort } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync$1, readlinkSync, 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 { 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) => {
+		const req = request({
+			hostname: "localhost",
+			port,
+			path: "/status",
+			timeout: 2e3
+		}, (res) => {
+			let data = "";
+			res.on("data", (chunk) => {
+				data += chunk;
+			});
+			res.on("end", () => resolve(data.includes("packager-status:running")));
+		});
+		req.on("error", () => resolve(false));
+		req.on("timeout", () => {
+			req.destroy();
+			resolve(false);
+		});
+		req.end();
+	});
+}
+function isPortFree(port, { timeoutMs = 400 } = {}) {
+	return new Promise((resolve) => {
+		const sock = connect({
+			port,
+			host: "127.0.0.1"
+		});
+		const done = (free) => {
+			sock.removeAllListeners();
+			sock.destroy();
+			resolve(free);
+		};
+		sock.setTimeout(timeoutMs);
+		sock.once("connect", () => done(false));
+		sock.once("error", () => done(true));
+		sock.once("timeout", () => done(false));
+	});
+}
+const FIRST_PORT = 8082;
+async function computeNextPort(isFree = isPortFree) {
+	const taken = new Set(allMetroPorts());
+	for (let port = FIRST_PORT; port < 8282; port++) {
+		if (taken.has(port)) continue;
+		if (await isFree(port)) return port;
+	}
+	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();
+	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 (!isMounted(path, mounted)) continue;
+		if (typeof proj.metroPort === "number") candidates.push({
+			port: proj.metroPort,
+			ownerPath: path
+		});
+	}
+	for (const c of candidates) if (!await probe(c.port)) return c;
+	return null;
+}
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	const reclaim = await findReclaimablePort(projectPath, probe);
+	if (reclaim && await isFree(reclaim.port)) {
+		releaseMetroPort(reclaim.ownerPath, reclaim.port);
+		return reclaim.port;
+	}
+	return computeNextPort(isFree);
+}
+const RESERVE_ATTEMPTS = 5;
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
+		const port = await allocatePort(projectPath, probe, isFree);
+		const claimed = claimMetroPort(projectPath, port);
+		if (claimed !== null) return claimed;
+	}
+	throw new Error(`Could not reserve a Metro port after ${RESERVE_ATTEMPTS} attempts: another Stim run claimed each one first. Retry.`);
+}
+//#endregion
+//#region src/metro.ts
+/**
+* True when some process with this pid exists right now. It cannot tell a recycled pid from the
+* process that first held it, so it is only valid for a pid this run spawned and still holds a
+* handle on. For a pid read from a record on disk, decide with `inspectProcessIdentity` on that
+* record's process token, or take an ownership claim (`ownership-claim.ts`): this answer would keep
+* a dead holder's record looking live until some unrelated process exits.
+*/
+function pidExists(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+function parseLsofPids(out) {
+	if (!out) return [];
+	return String(out).split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isFinite(n));
+}
+function addressPort(address) {
+	const colon = String(address ?? "").lastIndexOf(":");
+	return colon < 0 ? NaN : Number(String(address).slice(colon + 1));
+}
+function parseNetstatPids(out, port) {
+	const pids = [];
+	for (const line of String(out ?? "").split("\n")) {
+		const cols = line.trim().split(/\s+/);
+		if (cols.length < 5 || cols[0]?.toUpperCase() !== "TCP") continue;
+		if (addressPort(cols[1]) !== port || addressPort(cols[2]) !== 0) continue;
+		const pid = Number(cols.at(-1));
+		if (Number.isSafeInteger(pid) && pid > 0 && !pids.includes(pid)) pids.push(pid);
+	}
+	return pids;
+}
+function listeningPids(port, platform = process.platform) {
+	const pids = parseLsofPids(getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`));
+	if (pids.length > 0 || platform !== "win32") return pids;
+	return parseNetstatPids(getExecutor().runQuiet("netstat -ano"), port);
+}
+function parseLsofCwd(out) {
+	if (!out) return null;
+	const lines = String(out).split("\n");
+	const idx = lines.findIndex((l) => l === "fcwd");
+	if (idx === -1) return null;
+	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
+	return nLine ? nLine.slice(1) : null;
+}
+function lsofOutput(args) {
+	return getExecutor().runFileAsync("lsof", args).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
+}
+function parseLsofListeners(out) {
+	const byPort = /* @__PURE__ */ new Map();
+	let pid = null;
+	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) pid = parseInt(line.slice(1), 10);
+	else if (line.startsWith("n") && pid !== null && Number.isFinite(pid)) {
+		const port = addressPort(line.slice(1));
+		const pids = byPort.get(port) ?? [];
+		if (!pids.includes(pid)) pids.push(pid);
+		byPort.set(port, pids);
+	}
+	return byPort;
+}
+/**
+* `listeningPids` for several ports with one lsof call. A port lsof could not be asked about is
+* missing from the map.
+*/
+async function listeningPidsByPort(ports) {
+	const result = /* @__PURE__ */ new Map();
+	if (ports.length === 0) return result;
+	const out = await lsofOutput([
+		"-nP",
+		`-iTCP:${ports.join(",")}`,
+		"-sTCP:LISTEN",
+		"-Fpn"
+	]);
+	if (out === null) return result;
+	const found = parseLsofListeners(out);
+	for (const port of ports) result.set(port, found.get(port) ?? []);
+	return result;
+}
+function parseLsofCwds(out) {
+	const cwds = /* @__PURE__ */ new Map();
+	let pid = null;
+	let inCwd = false;
+	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) {
+		pid = parseInt(line.slice(1), 10);
+		inCwd = false;
+	} else if (line.startsWith("f")) inCwd = line === "fcwd";
+	else if (inCwd && line.startsWith("n") && pid !== null && !cwds.has(pid)) cwds.set(pid, line.slice(1));
+	return cwds;
+}
+/** `processCwd` for several pids with at most one lsof call. A pid lsof could not be asked about is missing from the map. */
+async function processCwds(pids) {
+	const cwds = /* @__PURE__ */ new Map();
+	const viaLsof = [];
+	for (const pid of new Set(pids)) {
+		let cwd = null;
+		if (process.platform === "linux") try {
+			cwd = readlinkSync(`/proc/${pid}/cwd`);
+		} catch {}
+		if (cwd) cwds.set(pid, cwd);
+		else viaLsof.push(pid);
+	}
+	if (viaLsof.length === 0) return cwds;
+	const out = await lsofOutput([
+		"-a",
+		"-p",
+		viaLsof.join(","),
+		"-d",
+		"cwd",
+		"-Fn"
+	]);
+	if (out === null) return cwds;
+	const found = parseLsofCwds(out);
+	for (const pid of viaLsof) cwds.set(pid, found.get(pid) ?? null);
+	return cwds;
+}
+function processCwd(pid) {
+	if (process.platform === "linux") try {
+		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);
+	} catch {
+		return path;
+	}
+}
+function isInsideProject(cwd, projectPath) {
+	if (!cwd || !projectPath) return false;
+	const a = canonicalPath(cwd);
+	const b = canonicalPath(projectPath);
+	return a === b || a.startsWith(b.endsWith(sep) ? b : b + sep);
+}
+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;
+	if (supervisor?.port !== port || (0, process_identity_exports.inspectProcessIdentity)(supervisor) !== "same") return null;
+	return supervisor;
+}
+async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning, pidsOf = listeningPids, cwdOf = processCwd } = {}) {
+	const pid = (await pidsOf(port))[0];
+	if (pid === void 0) return { missing: true };
+	if (!await probe(port)) return {
+		notOurs: `pid ${pid} on port ${port} does not answer Metro's /status`,
+		kind: NOT_OURS_UNRESPONSIVE,
+		pid
+	};
+	const cwd = await cwdOf(pid);
+	if (!cwd) {
+		const owner = ownedSupervisor(projectPath, port);
+		if (owner && (pid === owner.pid || pid === owner.serverPid)) return { metro: {
+			pid,
+			leader: owner.pid,
+			cwd: canonicalPath(projectPath),
+			processToken: owner.processToken
+		} };
+		return {
+			notOurs: `pid ${pid} on port ${port}: working directory could not be read`,
+			kind: NOT_OURS_UNREADABLE_CWD,
+			pid
+		};
+	}
+	if (!isInsideProject(cwd, projectPath)) return {
+		notOurs: `pid ${pid} on port ${port} runs from ${cwd}, outside ${projectPath}`,
+		kind: NOT_OURS_FOREIGN_CWD,
+		pid
+	};
+	const owner = ownedSupervisor(projectPath, port);
+	return { metro: {
+		pid,
+		leader: owner ? owner.pid : pid,
+		cwd,
+		...owner ? { processToken: owner.processToken } : {}
+	} };
+}
+/**
+* Terminate a process and everything it spawned. On POSIX `group` signals the process group, which
+* is what a detached leader owns. Windows has no process groups, and its SIGTERM is
+* TerminateProcess: no handler runs and no child is reached, so a spawned dev server or `adb
+* logcat` would outlive its parent. taskkill /T is the only route to the tree there, and it is
+* always forceful.
+*/
+function signalProcessTree(pid, signal = "SIGTERM", { group = false, platform = process.platform } = {}) {
+	if (platform !== "win32") return process.kill(group ? -pid : pid, signal);
+	return getExecutor().runFileQuiet("taskkill", [
+		"/PID",
+		String(pid),
+		"/T",
+		"/F"
+	]) !== null;
+}
+function killMetroTree(leader, processToken) {
+	if (!leader || leader === process.pid || (0, process_identity_exports.inspectProcessIdentity)({
+		pid: leader,
+		processToken
+	}) !== "same") return false;
+	try {
+		return signalProcessTree(leader, "SIGTERM", { group: true });
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { workspaceLogErrorIndex as A, sharedCcache as C, workspaceDerivedData as D, supervisorPidFile as E, workspaceName$1 as M, workspaceStateFile as N, workspaceDir as O, withDirLock as P, sharedBuildCache as S, supervisorLogFile as T, withWorkspaceStateLock as _, processCwd as a, emulatorLogFile as b, signalProcessTree as c, reserveMetroPort as d, clearWorkspaceStateKey as f, updateWorkspaceState as g, recordWorkspaceUse as h, pidExists as i, workspaceLogsDir as j, workspaceId as k, isMetroRunning as l, readWorkspaceState$1 as m, listeningPids as n, processCwds as o, clearWorkspaceStateKeys as p, listeningPidsByPort as r, resolveProjectMetro as s, killMetroTree as t, isPortFree as u, workspaceLastUsed as v, sharedCompilationCache as w, ensureWorkspaceStorage as x, writeWorkspaceState as y };

package/dist/{named-ports-DzMOlmaX.mjs → named-ports-DiTfSz6p.mjs}

@@ -1,7 +1,7 @@
-import { t as getExecutor } from "./exec-B29XNuhP.mjs";
-import { C as withConfigLock, f as getProject, g as loadConfig, s as ensureConfig, u as getConfigDir, w as process_identity_exports, y as saveConfig } from "./config-B7iyKWkL.mjs";
-import { c as isPortFree, o as signalProcessTree, r as listeningPids } from "./metro-C7bcJ0uo.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
+import { D as process_identity_exports, T as withConfigLock, f as getProject, g as loadConfig, s as ensureConfig, u as getConfigDir, x as saveConfig } from "./config-BEq0Qw_a.mjs";
+import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { c as signalProcessTree, n as listeningPids, u as isPortFree } from "./metro-BWLOJ_Wr.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
 import { realpathSync } from "node:fs";
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;

package/dist/{ndjson-BZwI1NBv.mjs → ndjson-CDY9IkVC.mjs}

@@ -1,47 +1,9 @@
 import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { dirname } from "path";
+import { rotateLog } from "@stim-cli/core";
+import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations } from "@stim-cli/core/state";
 //#region src/ndjson.ts
-const LEVELS = [
-	"debug",
-	"info",
-	"warn",
-	"error",
-	"fatal"
-];
-const SOURCES = [
-	"metro",
-	"client",
-	"device",
-	"build"
-];
-function levelRank(level) {
-	const i = LEVELS.indexOf(level);
-	return i < 0 ? 0 : i;
-}
-function parseNdjsonLine(line) {
-	if (typeof line !== "string") return null;
-	const trimmed = line.trim();
-	if (!trimmed) return null;
-	let value;
-	try {
-		value = JSON.parse(trimmed);
-	} catch {
-		return null;
-	}
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	return value;
-}
-function parseNdjsonText(text) {
-	if (typeof text !== "string" || text === "") return [];
-	const out = [];
-	const lines = text.split("\n");
-	lines.pop();
-	for (const line of lines) {
-		const record = parseNdjsonLine(line);
-		if (record) out.push(record);
-	}
-	return out;
-}
+const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
 	try {
 		return `${JSON.stringify(record)}\n`;
@@ -49,9 +11,11 @@ function formatNdjsonLine(record) {
 		return null;
 	}
 }
-function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
+function createNdjsonWriter(file, { truncate = false, fields = {}, maxBytes, now = Date.now } = {}) {
 	let fd = null;
 	let freshFile = truncate;
+	let uncheckedBytes = 0;
+	let checkedAt = 0;
 	let written = 0;
 	let dropped = 0;
 	let lastError = null;
@@ -61,6 +25,20 @@ function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
 		fd = openSync(file, freshFile ? "w" : "a");
 		freshFile = false;
 	}
+	function rotateIfDue(limit) {
+		if (fd !== null && uncheckedBytes < limit / 8 && now() - checkedAt < ROTATE_CHECK_MS) return;
+		if (fd !== null) {
+			try {
+				closeSync(fd);
+			} catch {}
+			fd = null;
+		}
+		uncheckedBytes = 0;
+		checkedAt = now();
+		try {
+			rotateLog(file, limit);
+		} catch {}
+	}
 	function write(record) {
 		if (closed) {
 			dropped += 1;
@@ -76,8 +54,10 @@ function createNdjsonWriter(file, { truncate = false, fields = {} } = {}) {
 			return false;
 		}
 		try {
+			if (maxBytes !== void 0) rotateIfDue(maxBytes);
 			if (fd === null) open();
 			writeSync(fd, line);
+			uncheckedBytes += Buffer.byteLength(line);
 			written += 1;
 			return true;
 		} catch (err) {
@@ -131,4 +111,4 @@ function stamp(record) {
 	};
 }
 //#endregion
-export { parseNdjsonLine as a, levelRank as i, SOURCES as n, parseNdjsonText as o, createNdjsonWriter as r, LEVELS as t };
+export { parseNdjsonLine as a, levelRank as i, SOURCES as n, readNdjsonGenerations as o, createNdjsonWriter as r, LEVELS as t };

package/dist/{ndjson-DvHSsNU9.d.mts → ndjson-Du3j0AQ9.d.mts}

@@ -1,3 +1,4 @@
+import "@stim-cli/core/state";
 //#region src/ndjson.d.ts
 interface NdjsonWriter {
   readonly file: string;

package/dist/{ownership-Cp52QAK1.mjs → ownership-D2xbLVoz.mjs}

@@ -1,6 +1,5 @@
-import { w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { a as withWorkspaceStateLock, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { i as pidExists } from "./metro-C7bcJ0uo.mjs";
+import { D as process_identity_exports } from "./config-BEq0Qw_a.mjs";
+import { _ as withWorkspaceStateLock, i as pidExists, m as readWorkspaceState, y as writeWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {