stim 1.17.2 → 1.19.0

package/dist/{metro-g8NqiJp-.mjs → metro-DI2AjPF_.mjs}

@@ -1,12 +1,198 @@
-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-DqcCbpE7.mjs";
-import { existsSync, readlinkSync, realpathSync } from "fs";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-DC5jEtd1.mjs";
+import { r as readWorkspaceState } from "./workspace-state-CR9X86xJ.mjs";
 import { sep } from "path";
+import { existsSync, readlinkSync, realpathSync } from "fs";
+import { readFile } from "node:fs/promises";
 import { request } from "http";
-import { connect } from "net";
+import { connect } from "node:net";
+//#region src/listening-ports.ts
+/**
+* Returns occupied TCP ports across local interfaces. Rejects if listener inspection fails.
+*/
+async function readListeningPorts(platform = process.platform) {
+	switch (platform) {
+		case "darwin": return parseDarwinPorts(await readNetstat("/usr/sbin/netstat", [
+			"-anL",
+			"-p",
+			"tcp"
+		]));
+		case "linux": return parseLinuxPorts(await Promise.all([readFile("/proc/net/tcp", "utf8"), readFile("/proc/net/tcp6", "utf8").catch((error) => {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		})]));
+		case "win32": return parseWindowsPorts(await readNetstat("netstat", ["-an"]));
+		default: throw new Error(`TCP listener inspection is not supported on ${platform}.`);
+	}
+}
+const DARWIN_TITLE = "Current listen queue sizes (qlen/incqlen/maxqlen)";
+const DARWIN_COLUMNS = /^Listen\s+Local Address$/;
+const DARWIN_TABLE_CHANGE = /^Some tcp sockets may have been (?:created|deleted|created or deleted)\.?$/;
+const DARWIN_LISTENER = /^\d+\/\d+\/\d+\s+\S+\.(?<port>\d+)$/;
+function parseDarwinPorts(output) {
+	const ports = /* @__PURE__ */ new Set();
+	let title = false;
+	let columns = false;
+	for (const raw of output.split("\n")) {
+		const line = raw.trim();
+		if (line === DARWIN_TITLE) title = true;
+		else if (DARWIN_COLUMNS.test(line)) columns = true;
+		if (!line || line === DARWIN_TITLE || DARWIN_COLUMNS.test(line) || DARWIN_TABLE_CHANGE.test(line)) continue;
+		const listener = DARWIN_LISTENER.exec(line)?.groups;
+		if (!listener) throw new Error("Cannot parse the TCP listen table from netstat.");
+		addPort(ports, Number(listener.port));
+	}
+	if (!title || !columns) throw new Error("netstat printed no TCP listen table.");
+	return ports;
+}
+const LINUX_COLUMNS = /^\s*sl\s+local_address\s+rem(?:ote)?_address\s+st\s/;
+const LINUX_TCP_STATE = /^[0-9A-F]{2}$/i;
+const LINUX_LOCAL_ADDRESS = /^(?:[0-9A-F]{8}|[0-9A-F]{32}):(?<port>[0-9A-F]{4})$/i;
+const LINUX_LISTEN_STATE = "0A";
+function parseLinuxPorts(tables) {
+	const ports = /* @__PURE__ */ new Set();
+	for (const table of tables) {
+		if (table === null) continue;
+		const [header, ...rows] = table.trim().split("\n");
+		if (!header || !LINUX_COLUMNS.test(header)) throw new Error("Cannot parse the TCP socket table from /proc/net.");
+		for (const raw of rows) {
+			const line = raw.trim();
+			if (!line) continue;
+			const [, localAddress, , state] = line.split(/\s+/);
+			if (!state || !LINUX_TCP_STATE.test(state)) throw new Error("Invalid TCP state in /proc/net.");
+			if (state.toUpperCase() !== LINUX_LISTEN_STATE) continue;
+			const listener = localAddress && LINUX_LOCAL_ADDRESS.exec(localAddress)?.groups;
+			if (!listener) throw new Error("Invalid TCP listener in /proc/net.");
+			addPort(ports, Number(`0x${listener.port}`));
+		}
+	}
+	return ports;
+}
+const WINDOWS_COLUMNS = /^Proto\s/;
+const WINDOWS_TCP_ROW = /^TCP\s+\S*:(?<localPort>\d+)\s+\S*:(?<remotePort>\d+)\s+\S/;
+function parseWindowsPorts(output) {
+	const ports = /* @__PURE__ */ new Set();
+	let table = false;
+	for (const raw of output.split("\n")) {
+		const line = raw.trim();
+		if (WINDOWS_COLUMNS.test(line)) table = true;
+		const [protocol] = line.split(/\s+/, 1);
+		if (protocol !== "TCP") continue;
+		table = true;
+		const connection = WINDOWS_TCP_ROW.exec(line)?.groups;
+		if (!connection) throw new Error("Cannot parse the TCP connection table from netstat.");
+		if (Number(connection.remotePort) === 0) addPort(ports, Number(connection.localPort));
+	}
+	if (!table) throw new Error("netstat printed no TCP connection table.");
+	return ports;
+}
+function readNetstat(file, args) {
+	return getExecutor().runFileAsync(file, args, {
+		timeoutMs: 5e3,
+		rejectStderr: true,
+		env: { LC_ALL: "C" }
+	});
+}
+function addPort(ports, port) {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid TCP listener port.");
+	ports.add(port);
+}
+function addressPort(address) {
+	const colon = String(address ?? "").lastIndexOf(":");
+	return colon < 0 ? NaN : Number(String(address).slice(colon + 1));
+}
+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;
+}
+const PORT_INSPECTION_REMEDY = "Allow Stim to run netstat or lsof, or to connect to 127.0.0.1 and ::1, then retry. A metro.port pin skips the scan for Metro.";
+var PortInspectionError = class extends Error {
+	code = "STIM_PORT_INSPECTION_FAILED";
+	reason;
+	constructor(reason) {
+		super(`${reason} ${PORT_INSPECTION_REMEDY}`);
+		this.reason = reason;
+	}
+};
+/**
+* Returns the TCP ports lsof lists as listening, or null when lsof cannot list them.
+*/
+async function readLsofListeningPorts() {
+	try {
+		const out = await getExecutor().runFileAsync("lsof", [
+			"-nP",
+			"-iTCP",
+			"-sTCP:LISTEN",
+			"-Fpn"
+		], { timeoutMs: 5e3 });
+		return new Set([...parseLsofListeners(out).keys()].filter(Number.isInteger));
+	} catch (error) {
+		const result = error;
+		if (result.status === 1 && !String(result.stdout ?? "").trim() && !String(result.stderr ?? "").trim()) return /* @__PURE__ */ new Set();
+		return null;
+	}
+}
+const IPV6_UNAVAILABLE = /* @__PURE__ */ new Set([
+	"EADDRNOTAVAIL",
+	"EAFNOSUPPORT",
+	"ENETUNREACH"
+]);
+/**
+* Connects to a loopback port: `taken` when something accepts or the connect hangs, `free` when
+* it is refused or IPv6 is unavailable, `unknown` for any other connect error.
+*/
+function probeLoopback(port, host, timeoutMs = 400) {
+	return new Promise((resolve) => {
+		const socket = connect({
+			port,
+			host
+		});
+		const done = (answer) => {
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(answer);
+		};
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => done("taken"));
+		socket.once("timeout", () => done("taken"));
+		socket.once("error", (error) => {
+			const refused = error.code === "ECONNREFUSED" || host === "::1" && IPV6_UNAVAILABLE.has(error.code ?? "");
+			done(refused ? "free" : "unknown");
+		});
+	});
+}
+//#endregion
 //#region src/ports.ts
+/**
+* Creates one lazy listener snapshot for an allocation attempt; discard the probe before retrying.
+* When the native TCP table cannot be read, each port is checked with an lsof listener scan and
+* loopback connects instead. Rejects with `PortInspectionError` only when none of them can answer.
+*/
+function createPortProbe() {
+	let snapshot;
+	let lsof;
+	return async (port) => {
+		const listening = await (snapshot ??= readListeningPorts().catch((error) => error instanceof Error ? error : new Error(String(error))));
+		if (!(listening instanceof Error)) return !listening.has(port);
+		const [listed, ipv4, ipv6] = await Promise.all([
+			lsof ??= readLsofListeningPorts(),
+			probeLoopback(port, "127.0.0.1"),
+			probeLoopback(port, "::1")
+		]);
+		if (listed?.has(port) || ipv4 === "taken" || ipv6 === "taken") return false;
+		if (listed || ipv4 === "free" && ipv6 === "free") return true;
+		throw new PortInspectionError(`Cannot tell whether TCP port ${port} is free: the TCP listener table failed (${listening.message.replace(/\s+/g, " ").trim()}), lsof could not list listeners, and a loopback connect failed.`);
+	};
+}
 function isMetroRunning(port) {
 	return new Promise((resolve) => {
 		const req = request({
@@ -29,25 +215,8 @@ function isMetroRunning(port) {
 		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) {
+async function computeNextPort(isFree = createPortProbe()) {
 	const taken = new Set(allMetroPorts());
 	for (let port = FIRST_PORT; port < 8282; port++) {
 		if (taken.has(port)) continue;
@@ -73,7 +242,7 @@ async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, {
 	for (const c of candidates) if (!await probe(c.port)) return c;
 	return null;
 }
-async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = createPortProbe()) {
 	const reclaim = await findReclaimablePort(projectPath, probe);
 	if (reclaim && await isFree(reclaim.port)) {
 		releaseMetroPort(reclaim.ownerPath, reclaim.port);
@@ -82,7 +251,7 @@ async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPort
 	return computeNextPort(isFree);
 }
 const RESERVE_ATTEMPTS = 5;
-async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree, pinned = null) {
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree, 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.`);
@@ -116,10 +285,6 @@ 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")) {
@@ -147,18 +312,6 @@ function parseLsofCwd(out) {
 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.
@@ -306,4 +459,4 @@ function killMetroTree(leader, processToken) {
 	}
 }
 //#endregion
-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 };
+export { listeningPidsByPort as a, processCwd as c, signalProcessTree as d, createPortProbe as f, PortInspectionError as g, PORT_INSPECTION_REMEDY as h, listeningPids as i, processCwds as l, reserveMetroPort as m, isInsideProject as n, parseNetstatPids as o, isMetroRunning as p, killMetroTree as r, pidExists as s, NOT_OURS_FOREIGN_CWD as t, resolveProjectMetro as u };

package/dist/{metro-gateway-C-ijGI2F.mjs → metro-gateway-BxpJLIwh.mjs}

@@ -1,8 +1,8 @@
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-DqcCbpE7.mjs";
-import { S as realIo } from "./client-SvBdgObD.mjs";
-import { randomBytes, randomUUID } from "node:crypto";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { L as realIo } from "./client-CuUo8Nvg.mjs";
 import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
+import { randomBytes, randomUUID } from "node:crypto";
 import { isIP } from "node:net";
 //#region src/device-host/metro-gateway.ts
 function gatewayAddresses(credential, status) {

package/dist/{metro-store-CDDZHtPl.mjs → metro-store-BAHFcJm6.mjs}

@@ -1,7 +1,21 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
 import { fileURLToPath } from "node:url";
+import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
+//#region src/supervisor/errors.ts
+function supervisorError(code, message, remedy) {
+	const err = new Error(message);
+	err.code = code;
+	if (remedy) err.remedy = remedy;
+	return err;
+}
+function describeError(err) {
+	if (!err) return "unknown error";
+	const e = err;
+	const message = e.message || String(err);
+	return `${e.code ? `${e.code}: ` : ""}${message}${e.remedy ? ` Remedy: ${e.remedy}` : ""}`;
+}
+//#endregion
 //#region src/supervisor/metro-store.ts
 function metroStoreName(root) {
 	try {
@@ -89,4 +103,4 @@ function expoMetroStoreEnv({ root, storeRoot, adapterPath, existingOverride }) {
 	};
 }
 //#endregion
-export { metroStoreRoot as a, metroStoreConfirmedRoot as i, expoMetroConfigPath as n, registerMetroStore as o, expoMetroStoreEnv as r, appendCacheStore as t };
+export { metroStoreRoot as a, supervisorError as c, metroStoreConfirmedRoot as i, expoMetroConfigPath as n, registerMetroStore as o, expoMetroStoreEnv as r, describeError as s, appendCacheStore as t };