stim 0.0.0 → 1.0.0

package/dist/android-jc8MnUyL.mjs

@@ -0,0 +1,514 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { A as listMountedVolumes, C as inspectProcessIdentity, g as removeProject, k as isOnMountedVolume, m as loadConfig, n as allMetroPorts, r as claimMetroPort, w as sameProcessRecord } from "./config-7kmtuhO2.mjs";
+import { _ as writeWorkspaceState, m as withWorkspaceStateLock, p as readWorkspaceState } from "./state-2nush3MK.mjs";
+import { realpathSync } from "node:fs";
+import { existsSync as existsSync$1, readlinkSync, realpathSync as realpathSync$1 } 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$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)) {
+		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
+function isPidAlive(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$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";
+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
+//#region src/collector/state.ts
+function collectorRoot(root) {
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+function registerCollector(root, platform, record) {
+	root = collectorRoot(root);
+	return withWorkspaceStateLock(root, () => {
+		const collectors = {
+			...readWorkspaceState(root)?.collectors,
+			[platform]: record
+		};
+		writeWorkspaceState(root, { collectors });
+		return collectors;
+	});
+}
+function unregisterCollector(root, platform, pid, processToken) {
+	root = collectorRoot(root);
+	return withWorkspaceStateLock(root, () => {
+		const collectors = { ...readWorkspaceState(root)?.collectors };
+		const record = collectors[platform];
+		if (!(platform in collectors) || record?.pid !== pid || record.processToken !== processToken) return collectors;
+		delete collectors[platform];
+		writeWorkspaceState(root, { collectors: Object.keys(collectors).length ? collectors : void 0 });
+		return collectors;
+	});
+}
+function readCollectors(root) {
+	return readWorkspaceState(collectorRoot(root))?.collectors || {};
+}
+//#endregion
+//#region src/collector/ownership.ts
+function collectorProcessTitle(platform, root) {
+	return `stim-collector-${platform} --root ${root}`;
+}
+function verifyCollectorOwnership({ pid, platform, root, isAlive = isPidAlive, expected }) {
+	const record = readCollectors(root)[platform];
+	if (expected !== void 0 && !sameProcessRecord(record, expected)) return {
+		status: "unverified",
+		reason: `the ${platform} collector registration changed during cleanup`
+	};
+	if (record?.pid === pid) {
+		const identity = inspectProcessIdentity(record);
+		if (identity === "same") return { status: "ours" };
+		if (identity === "gone" || identity === "different") return { status: "gone" };
+	}
+	return isAlive(pid) ? {
+		status: "unverified",
+		reason: `pid ${pid} has no verifiable identity recorded for this workspace's ${platform} collector`
+	} : { status: "gone" };
+}
+//#endregion
+//#region src/collector/ios-device.ts
+const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
+const DEV_MENU_LAUNCH_ARGS = [
+	"-EXDevMenuShowsAtLaunch",
+	"0",
+	"-EXDevMenuShowFloatingActionButton",
+	"0"
+];
+const FATAL_MARKERS = [
+	/^\*\*\* Terminating app due to uncaught exception/,
+	/^libc\+\+abi: terminating/,
+	/^\*\*\* Assertion failure in/,
+	/^(?:\S+:\d+: )?Fatal error: /
+];
+const MIRROR_LINE = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+[+-]\d{4}) (.+?)\[(\d+):(\d+)\] ?(?:\[([^\]\s]+)\] )?([\s\S]*)$/;
+function deviceConsoleLevel(message) {
+	const text = typeof message === "string" ? message : "";
+	return FATAL_MARKERS.some((marker) => marker.test(text)) ? "fatal" : "info";
+}
+function parseDeviceConsoleLine(line, { now = Date.now } = {}) {
+	if (typeof line !== "string") return null;
+	const text = line.replace(/\r$/, "").trimEnd();
+	if (!text.trim()) return null;
+	const match = MIRROR_LINE.exec(text);
+	const record = {
+		ts: now(),
+		src: "device",
+		level: "info",
+		msg: text,
+		raw: true
+	};
+	if (!match) {
+		record.level = text.startsWith("ERROR: ") ? "error" : deviceConsoleLevel(text);
+		return record;
+	}
+	const [, timestamp, proc, pid, , category, message] = match;
+	if (message === void 0 || !message.trim()) return null;
+	const parsed = Date.parse(timestamp);
+	if (Number.isFinite(parsed)) record.ts = parsed;
+	record.msg = message;
+	record.level = deviceConsoleLevel(message);
+	record.proc = `${proc}(${pid})`;
+	if (category) record.category = category;
+	return record;
+}
+function deviceConsoleArgs({ udid, bundleId, payloadUrl = null }) {
+	const args = [
+		"devicectl",
+		"device",
+		"process",
+		"launch",
+		"--quiet",
+		"--device",
+		udid,
+		"--console",
+		"--terminate-existing",
+		"--environment-variables",
+		JSON.stringify(CONSOLE_ENV)
+	];
+	if (payloadUrl) args.push("--payload-url", payloadUrl);
+	args.push(bundleId);
+	if (payloadUrl) args.push("--", ...DEV_MENU_LAUNCH_ARGS);
+	return args;
+}
+function startIosDeviceConsole({ udid, bundleId, payloadUrl = null, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("xcrun", deviceConsoleArgs({
+		udid,
+		bundleId,
+		payloadUrl
+	}), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+//#endregion
+//#region src/collector/android.ts
+const LEVEL_BY_LETTER = {
+	V: "debug",
+	D: "debug",
+	I: "info",
+	W: "warn",
+	E: "error",
+	F: "fatal",
+	A: "fatal",
+	S: "debug"
+};
+function levelFromLogcatLetter(letter) {
+	return LEVEL_BY_LETTER[String(letter || "").toUpperCase()] ?? "info";
+}
+const NOISE_TAGS = /* @__PURE__ */ new Set([
+	"libEGL",
+	"EGL_emulation",
+	"eglCodecCommon",
+	"emuglGLESv2_enc",
+	"HostConnection",
+	"OpenGLRenderer",
+	"gralloc4",
+	"Gralloc4",
+	"vulkan",
+	"GraphicBufferAllocator",
+	"BufferQueueProducer",
+	"Surface",
+	"ziparchive",
+	"chatty"
+]);
+function levelForLogcat(letter, tag) {
+	const level = levelFromLogcatLetter(letter);
+	if (level !== "error") return level;
+	return NOISE_TAGS.has(String(tag || "").trim()) ? "info" : level;
+}
+const LOGCAT_TIME = /^(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})\.(\d{3})\s+([A-Z])\/(.*?)\(\s*(\d+)\):\s?(.*)$/;
+const LOGCAT_EPOCH = /^\s*(\d+)\.(\d{3,6})\s+([A-Z])\/(.*?)\(\s*(\d+)\):\s?(.*)$/;
+function parseLogcatTimestamp({ month, day, hour, minute, second, millis }, now = Date.now()) {
+	const ref = new Date(now);
+	let ts = new Date(ref.getFullYear(), month - 1, day, hour, minute, second, millis).getTime();
+	if (ts - now > 864e5) ts = new Date(ref.getFullYear() - 1, month - 1, day, hour, minute, second, millis).getTime();
+	return ts;
+}
+function parseLogcatLine(line, { now = Date.now, clockOffsetMs = null } = {}) {
+	if (typeof line !== "string") return null;
+	const epoch = LOGCAT_EPOCH.exec(line.trimEnd());
+	if (epoch) {
+		const [, seconds, fraction, letter, tag, pid, msg] = epoch;
+		if (!letter || !tag || !msg?.trim()) return null;
+		const deviceTs = Number(seconds) * 1e3 + Number(fraction.slice(0, 3));
+		if (!Number.isSafeInteger(deviceTs)) return null;
+		return {
+			ts: deviceTs + (clockOffsetMs ?? 0),
+			deviceTs,
+			...clockOffsetMs === null ? {} : { clockOffsetMs },
+			src: "device",
+			level: levelForLogcat(letter, tag),
+			msg,
+			proc: `${tag.trim()}(${pid})`
+		};
+	}
+	const m = LOGCAT_TIME.exec(line.trimEnd());
+	if (!m) return null;
+	const [, month, day, hour, minute, second, millis, letter, tag, pid, msg] = m;
+	if (letter === void 0 || tag === void 0 || msg === void 0) return null;
+	if (!msg.trim()) return null;
+	return {
+		ts: parseLogcatTimestamp({
+			month: Number(month),
+			day: Number(day),
+			hour: Number(hour),
+			minute: Number(minute),
+			second: Number(second),
+			millis: Number(millis)
+		}, now()),
+		src: "device",
+		level: levelForLogcat(letter, tag),
+		msg,
+		proc: `${tag.trim()}(${pid})`
+	};
+}
+function logcatArgs(serial, pid) {
+	return [
+		"-s",
+		serial,
+		"logcat",
+		"--pid",
+		String(pid),
+		"-v",
+		"time,epoch"
+	];
+}
+function androidClockOffset(serial, { exec = getExecutor(), now = Date.now } = {}) {
+	const before = now();
+	try {
+		const output = exec.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"date",
+			"+%s%3N"
+		], { timeoutMs: 1e3 }).trim();
+		const after = now();
+		if (!/^\d{13}$/.test(output) || after < before || after - before > 1e3) return null;
+		return Math.round((before + after) / 2) - Number(output);
+	} catch {
+		return null;
+	}
+}
+function parsePidof(text) {
+	const first = String(text ?? "").trim().split(/\s+/)[0];
+	const pid = Number(first);
+	return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function resolveAppPid(serial, packageName, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	try {
+		return parsePidof(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"pidof",
+			"-s",
+			packageName
+		]));
+	} catch {
+		return null;
+	}
+}
+async function waitForAppPid({ serial, packageName, timeoutMs = 3e4, pollMs = 500, exec = null, now = Date.now, sleep = defaultSleep }) {
+	const deadline = now() + timeoutMs;
+	for (;;) {
+		const pid = resolveAppPid(serial, packageName, { exec });
+		if (pid) return {
+			ok: true,
+			pid
+		};
+		if (now() >= deadline) return {
+			failed: true,
+			reason: `No process for ${packageName} appeared on ${serial} within ${Math.round(timeoutMs / 1e3)}s.`
+		};
+		await sleep(pollMs);
+	}
+}
+function defaultSleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+function startAndroidLogcat({ serial, pid, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("adb", logcatArgs(serial, pid), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+const PID_WATCH_MS = 3e3;
+function pidWatchInterval() {
+	const override = Number(process.env.STIM_PID_WATCH_MS);
+	return Number.isFinite(override) && override > 0 ? override : PID_WATCH_MS;
+}
+function watchAppPid({ serial, packageName, pid, intervalMs = null, exec = null, onChange, resolve = resolveAppPid, setTimer = setTimeout, clearTimer = clearTimeout }) {
+	const every = intervalMs ?? pidWatchInterval();
+	let current = pid;
+	let stopped = false;
+	let timer = null;
+	const tick = async () => {
+		timer = null;
+		if (stopped) return;
+		let next = null;
+		try {
+			next = resolve(serial, packageName, { exec });
+		} catch {}
+		if (next && next !== current) {
+			current = next;
+			try {
+				await onChange(next);
+			} catch {}
+		}
+		if (!stopped) timer = setTimer(tick, every);
+	};
+	timer = setTimer(tick, every);
+	return {
+		stop() {
+			stopped = true;
+			if (timer) clearTimer(timer);
+			timer = null;
+		},
+		probe() {
+			try {
+				return resolve(serial, packageName, { exec });
+			} catch {
+				return null;
+			}
+		},
+		get pid() {
+			return current;
+		}
+	};
+}
+//#endregion
+export { killMetroTree as _, watchAppPid as a, reserveMetroPort as b, parseDeviceConsoleLine as c, verifyCollectorOwnership as d, readCollectors as f, isPidAlive as g, NOT_OURS_FOREIGN_CWD as h, waitForAppPid as i, startIosDeviceConsole as l, unregisterCollector as m, parseLogcatLine as n, DEV_MENU_LAUNCH_ARGS as o, registerCollector as p, startAndroidLogcat as r, deviceConsoleLevel as s, androidClockOffset as t, collectorProcessTitle as u, resolveProjectMetro as v, isMetroRunning as y };

package/dist/cache-manifest-4tH64LQ9.mjs

@@ -0,0 +1,66 @@
+import { l as getConfigDir } from "./config-7kmtuhO2.mjs";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import { readCacheManifest, updateCacheManifest } from "@stim-cli/core";
+//#region src/cache-manifest.ts
+function manifestPath() {
+	return join(getConfigDir(), "caches.json");
+}
+function expand(dir) {
+	return resolve(dir.startsWith("~") ? join(homedir(), dir.slice(1)) : dir);
+}
+function readManifest(path = manifestPath()) {
+	return {
+		version: 1,
+		caches: cacheEntries(readCacheManifest(path).caches)
+	};
+}
+function cacheEntries(caches) {
+	return caches.filter((cache) => typeof cache.dir === "string");
+}
+function register(entry, path = manifestPath()) {
+	if (!entry?.dir) throw new Error("a cache registration needs a `dir`");
+	const dir = expand(entry.dir);
+	const record = {
+		dir,
+		name: entry.name || dir,
+		prune: entry.prune === "atomic" ? "atomic" : "entries",
+		entriesDepth: normalizeDepth(entry.entriesDepth),
+		note: entry.note || "registered by the project",
+		registeredBy: entry.registeredBy || process.cwd()
+	};
+	if (entry.layout) record.layout = entry.layout;
+	updateCacheManifest(path, (caches) => {
+		return [...cacheEntries(caches).filter((cache) => expand(cache.dir) !== dir), record];
+	});
+	return record;
+}
+function normalizeDepth(value) {
+	const n = Number(value);
+	if (!Number.isInteger(n) || n < 1) return 1;
+	return n;
+}
+function unregister(dir, path = manifestPath()) {
+	const target = expand(dir);
+	let removed = false;
+	updateCacheManifest(path, (caches) => {
+		const entries = cacheEntries(caches);
+		const remaining = entries.filter((cache) => expand(cache.dir) !== target);
+		removed = remaining.length !== entries.length;
+		return remaining;
+	});
+	return removed;
+}
+function registeredCaches(path = manifestPath()) {
+	return readManifest(path).caches.filter((c) => c.dir && existsSync(c.dir)).map((c) => ({
+		name: c.name,
+		dir: c.dir,
+		prune: c.prune === "atomic" ? "atomic" : "entries",
+		entriesDepth: normalizeDepth(c.entriesDepth),
+		note: c.note,
+		layout: c.layout
+	}));
+}
+//#endregion
+export { unregister as a, registeredCaches as i, readManifest as n, register as r, manifestPath as t };

package/dist/cache-manifest.d.mts

@@ -0,0 +1,27 @@
+//#region src/cache-manifest.d.ts
+interface CacheEntry {
+  dir: string;
+  name?: string;
+  prune?: "atomic" | "entries";
+  entriesDepth?: number;
+  note?: string;
+  registeredBy?: string;
+  layout?: string;
+}
+declare function manifestPath(): string;
+declare function readManifest(path?: string): {
+  version: number;
+  caches: CacheEntry[];
+};
+declare function register(entry: CacheEntry, path?: string): CacheEntry;
+declare function unregister(dir: string, path?: string): boolean;
+declare function registeredCaches(path?: string): {
+  name: string | undefined;
+  dir: string;
+  prune: "atomic" | "entries";
+  entriesDepth: number;
+  note: string | undefined;
+  layout: string | undefined;
+}[];
+//#endregion
+export { CacheEntry, manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cache-manifest.mjs

@@ -0,0 +1,2 @@
+import { a as unregister, i as registeredCaches, n as readManifest, r as register, t as manifestPath } from "./cache-manifest-4tH64LQ9.mjs";
+export { manifestPath, readManifest, register, registeredCaches, unregister };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}