stim 1.3.1 → 1.4.0

package/dist/metro-CORqXyTL.mjs

@@ -1,184 +0,0 @@
-import { t as getExecutor } from "./exec-CyylIdq9.mjs";
-import { E as inspectProcessIdentity, M as isOnMountedVolume, N as listMountedVolumes, g as loadConfig, n as allMetroPorts, r as claimMetroPort, v as removeProject } from "./config-CcefMY2Q.mjs";
-import { p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
-import { existsSync, readlinkSync, realpathSync } from "fs";
-import { sep } from "path";
-import { request } from "http";
-import { connect } from "net";
-//#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();
-	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 (existsSync(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)) {
-		removeProject(reclaim.ownerPath);
-		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 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 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(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";
-async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning } = {}) {
-	const pid = parseLsofPids(getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`))[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 = processCwd(pid);
-	if (!cwd) 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 supervisor = readWorkspaceState(canonicalPath(projectPath))?.supervisor;
-	const owned = supervisor?.port === port && inspectProcessIdentity(supervisor) === "same";
-	return { metro: {
-		pid,
-		leader: owned ? supervisor.pid : pid,
-		cwd,
-		...owned ? { processToken: supervisor.processToken } : {}
-	} };
-}
-function killMetroTree(leader, processToken) {
-	if (!leader || leader === process.pid || inspectProcessIdentity({
-		pid: leader,
-		processToken
-	}) !== "same") return false;
-	try {
-		process.kill(-leader, "SIGTERM");
-		return true;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-export { isMetroRunning as a, resolveProjectMetro as i, killMetroTree as n, reserveMetroPort as o, pidExists as r, NOT_OURS_FOREIGN_CWD as t };