stim 0.0.0 → 1.0.0

package/dist/config-7kmtuhO2.mjs

@@ -0,0 +1,350 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join, normalize } from "path";
+import { homedir } from "os";
+import { withDirLock } from "@stim-cli/core";
+import { capture, check, decode } from "unique-pid";
+//#region src/fs-util.ts
+function volumeRootFor(path) {
+	const m = normalize(String(path)).match(/^\/volumes\/([^/]+)/i);
+	return m ? `/Volumes/${m[1]}` : "/";
+}
+function resolveWorkspaceRealish(workspacePath) {
+	const raw = String(workspacePath);
+	if (!raw.startsWith("/")) return null;
+	let current = raw;
+	const MAX_HOPS = 40;
+	for (let hops = 0; hops < MAX_HOPS; hops++) {
+		const normalized = normalize(current);
+		const segments = normalized.split("/").filter(Boolean);
+		let prefix = "";
+		let followedSymlink = false;
+		for (const segment of segments) {
+			prefix += `/${segment}`;
+			let st;
+			try {
+				st = lstatSync(prefix);
+			} catch (err) {
+				if (err && err.code === "ENOENT") return normalized;
+				return null;
+			}
+			if (st.isSymbolicLink()) {
+				let target;
+				try {
+					target = readlinkSync(prefix);
+				} catch {
+					return null;
+				}
+				current = `${target.startsWith("/") ? target : normalize(join(dirname(prefix), target))}${normalized.slice(prefix.length)}`;
+				followedSymlink = true;
+				break;
+			}
+		}
+		if (!followedSymlink) return normalized;
+	}
+	return null;
+}
+function isRealMount(entryDev, rootDev) {
+	return entryDev != null && rootDev != null && entryDev !== rootDev;
+}
+function listMountedVolumes({ statFn = statSync } = {}) {
+	const roots = ["/"];
+	let rootDev;
+	try {
+		rootDev = statFn("/").dev;
+	} catch {
+		return roots;
+	}
+	try {
+		for (const name of readdirSync("/Volumes")) {
+			const path = join("/Volumes", name);
+			let entryDev;
+			try {
+				entryDev = statFn(path).dev;
+			} catch {
+				continue;
+			}
+			if (isRealMount(entryDev, rootDev)) roots.push(path);
+		}
+	} catch {}
+	return roots;
+}
+function resolveVolumeRoot(path) {
+	const realish = resolveWorkspaceRealish(path);
+	return realish === null ? null : volumeRootFor(realish);
+}
+function isOnMountedVolume(path, mountedVolumes) {
+	const mounted = new Set(mountedVolumes || listMountedVolumes());
+	const volume = resolveVolumeRoot(path);
+	if (volume === null) return false;
+	return mounted.has(volume);
+}
+function directorySize(dir, { timeoutMs } = {}) {
+	let out;
+	try {
+		out = getExecutor().runFile("du", ["-sk", dir], { timeoutMs });
+	} catch {
+		return 0;
+	}
+	if (!out) return 0;
+	const kb = parseInt(out.split(/\s+/)[0] ?? "", 10);
+	return isNaN(kb) ? 0 : kb * 1024;
+}
+function formatBytes(bytes) {
+	if (bytes >= 1024 ** 3) return `${(bytes / 1024 ** 3).toFixed(1)}G`;
+	if (bytes >= 1024 ** 2) return `${Math.round(bytes / 1024 ** 2)}M`;
+	return `${Math.round(bytes / 1024)}K`;
+}
+//#endregion
+//#region src/process-identity.ts
+function sameProcessRecord(a, b) {
+	if (!a || !b) return !a && !b;
+	return a.pid === b.pid && a.processToken === b.processToken;
+}
+function captureProcessToken(pid) {
+	const result = capture(pid);
+	return result.ok ? result.value : null;
+}
+function inspectProcessIdentity(record) {
+	if (!record || typeof record.processToken !== "string") return "unknown";
+	const decoded = decode(record.processToken);
+	if (!decoded.ok || decoded.value.pid !== record.pid) return "unknown";
+	const result = check(record.processToken);
+	return result.ok ? result.value : "unknown";
+}
+async function waitForProcessExit(record, timeoutMs) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() <= deadline) {
+		const identity = inspectProcessIdentity(record);
+		if (identity === "different" || identity === "gone") return true;
+		if (Date.now() >= deadline) return false;
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	}
+	return false;
+}
+//#endregion
+//#region src/config.ts
+function getConfigDir() {
+	return process.env.STIM_HOME || join(homedir(), ".stim");
+}
+function getConfigPath() {
+	return join(getConfigDir(), "config.json");
+}
+function ensureDir() {
+	const dir = getConfigDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+const LOCK_DIR_NAME = "config.lock";
+function lockPath() {
+	return join(getConfigDir(), LOCK_DIR_NAME);
+}
+function withConfigLock(fn) {
+	return withDirLock(lockPath(), fn, { ensureParent: ensureDir });
+}
+function loadConfig() {
+	const p = getConfigPath();
+	if (!existsSync(p)) return null;
+	const raw = readFileSync(p, "utf-8");
+	try {
+		return JSON.parse(raw);
+	} catch (err) {
+		const corrupt = /* @__PURE__ */ new Error(`Stim config at ${p} is not valid JSON: ${err.message}\nIt holds the records of the simulators and emulators Stim owns, so it is never reset automatically.
+Repair the file, or move it aside to start over: mv "${p}" "${p}.broken"`);
+		corrupt.code = "STIM_CONFIG_CORRUPT";
+		throw corrupt;
+	}
+}
+function saveConfig(config) {
+	ensureDir();
+	const target = getConfigPath();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n");
+	try {
+		renameSync(tmp, target);
+	} catch (err) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+}
+const CONFIG_VERSION = 2;
+function ensureConfig() {
+	return withConfigLock(() => {
+		const existing = loadConfig();
+		if (existing) {
+			let changed = false;
+			if (!existing.repos) {
+				existing.repos = {};
+				changed = true;
+			}
+			if (existing.version !== CONFIG_VERSION) {
+				existing.version = CONFIG_VERSION;
+				changed = true;
+			}
+			if (changed) saveConfig(existing);
+			return existing;
+		}
+		const fresh = {
+			version: CONFIG_VERSION,
+			projects: {},
+			repos: {}
+		};
+		saveConfig(fresh);
+		return fresh;
+	});
+}
+function getProject(projectPath) {
+	return loadConfig()?.projects?.[projectPath] || null;
+}
+function requireAbsoluteProjectPath(projectPath) {
+	if (isAbsolute(projectPath)) return;
+	throw new Error(`Project key "${projectPath}" is not an absolute path. The registry is keyed by the realpath of a workspace root, so a relative key can never resolve.`);
+}
+function upsertProject(projectPath, fields) {
+	requireAbsoluteProjectPath(projectPath);
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		const existing = cfg.projects[projectPath] || {
+			metroPort: null,
+			platforms: {}
+		};
+		cfg.projects[projectPath] = {
+			...existing,
+			...fields
+		};
+		saveConfig(cfg);
+		return cfg.projects[projectPath];
+	});
+}
+function removeProject(projectPath) {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		if (!cfg?.projects?.[projectPath]) return;
+		delete cfg.projects[projectPath];
+		saveConfig(cfg);
+	});
+}
+function claimMetroPort(projectPath, port) {
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) throw new Error(`Project not registered: ${projectPath}`);
+		for (const [path, proj] of Object.entries(cfg.projects)) if (path !== projectPath && proj?.metroPort === port) return null;
+		cfg.projects[projectPath].metroPort = port;
+		saveConfig(cfg);
+		return port;
+	});
+}
+function setDevice(projectPath, platform, deviceFields) {
+	requireAbsoluteProjectPath(projectPath);
+	withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) throw new Error(`Project not registered: ${projectPath}`);
+		cfg.projects[projectPath].platforms = cfg.projects[projectPath].platforms || {};
+		cfg.projects[projectPath].platforms[platform] = deviceFields;
+		saveConfig(cfg);
+	});
+}
+function releaseAndroidConsolePort(projectPath, consolePort) {
+	return withConfigLock(() => {
+		const cfg = loadConfig();
+		const android = cfg?.projects?.[projectPath]?.platforms?.android;
+		if (!cfg || !android || android.consolePort !== consolePort) return false;
+		delete android.consolePort;
+		saveConfig(cfg);
+		return true;
+	});
+}
+function clearDevice(projectPath, platform) {
+	withConfigLock(() => {
+		const cfg = loadConfig();
+		if (!cfg?.projects?.[projectPath]?.platforms) return;
+		delete cfg.projects[projectPath].platforms[platform];
+		saveConfig(cfg);
+	});
+}
+function setSupervisor(projectPath, { pid, port, startedAt, processToken }) {
+	requireAbsoluteProjectPath(projectPath);
+	return withConfigLock(() => {
+		const cfg = ensureConfig();
+		if (!cfg.projects[projectPath]) cfg.projects[projectPath] = {
+			metroPort: null,
+			platforms: {}
+		};
+		cfg.projects[projectPath].supervisor = {
+			pid,
+			port,
+			startedAt,
+			processToken
+		};
+		saveConfig(cfg);
+		return cfg.projects[projectPath].supervisor;
+	});
+}
+function clearSupervisor(projectPath, expected) {
+	return withConfigLock(() => {
+		const cfg = loadConfig();
+		const current = cfg?.projects?.[projectPath]?.supervisor;
+		if (!current) return true;
+		if (expected !== void 0 && !sameProcessRecord(current, expected)) return false;
+		delete cfg.projects[projectPath].supervisor;
+		saveConfig(cfg);
+		return true;
+	});
+}
+function getConcurrencyLimits({ env = process.env } = {}) {
+	const c = loadConfig()?.concurrency || {};
+	return {
+		maxBuilds: resolveLimit(env.STIM_MAX_BUILDS, c.maxBuilds),
+		maxDevices: resolveLimit(env.STIM_MAX_DEVICES, c.maxDevices)
+	};
+}
+function resolveLimit(envVal, cfgVal) {
+	const raw = envVal !== void 0 && envVal !== null && envVal !== "" ? Number(envVal) : typeof cfgVal === "number" ? cfgVal : NaN;
+	if (!Number.isFinite(raw) || raw <= 0) return 0;
+	return Math.floor(raw);
+}
+function getProjectSettings(projectPath) {
+	return getProject(projectPath)?.settings || {};
+}
+function getRepoSettings(gitCommonDir) {
+	return loadConfig()?.repos?.[gitCommonDir]?.settings || {};
+}
+function isPathPrefix(prefix, path) {
+	if (prefix === path) return true;
+	const withSlash = prefix.endsWith("/") ? prefix : `${prefix}/`;
+	return path.startsWith(withSlash);
+}
+function findEnclosingWorktreeRoot(projectPath) {
+	const cfg = loadConfig();
+	if (!cfg?.projects) return null;
+	let best = null;
+	for (const [path, proj] of Object.entries(cfg.projects)) {
+		if (!proj?.worktreeRoot) continue;
+		if (!isPathPrefix(path, projectPath)) continue;
+		if (!best || path.length > best.length) best = path;
+	}
+	return best;
+}
+function allMetroPorts() {
+	const cfg = loadConfig();
+	if (!cfg?.projects) return [];
+	return Object.values(cfg.projects).map((p) => p.metroPort).filter((p) => typeof p === "number");
+}
+function allConsolePortsAndSerials({ isMounted = isOnMountedVolume } = {}) {
+	const cfg = loadConfig();
+	const result = {
+		androidConsolePorts: [],
+		androidPhysicalSerials: []
+	};
+	if (!cfg) return result;
+	for (const [path, proj] of Object.entries(cfg.projects || {})) {
+		if (!existsSync(path) && isMounted(path)) continue;
+		const android = proj.platforms?.android;
+		if (typeof android?.consolePort === "number") result.androidConsolePorts.push(android.consolePort);
+		if (android?.serial && !android.avdName) result.androidPhysicalSerials.push(android.serial);
+	}
+	return result;
+}
+//#endregion
+export { listMountedVolumes as A, inspectProcessIdentity as C, directorySize as D, withDirLock as E, formatBytes as O, captureProcessToken as S, waitForProcessExit as T, saveConfig as _, clearSupervisor as a, upsertProject as b, getConcurrencyLimits as c, getProjectSettings as d, getRepoSettings as f, removeProject as g, releaseAndroidConsolePort as h, clearDevice as i, volumeRootFor as j, isOnMountedVolume as k, getConfigDir as l, loadConfig as m, allMetroPorts as n, ensureConfig as o, isPathPrefix as p, claimMetroPort as r, findEnclosingWorktreeRoot as s, allConsolePortsAndSerials as t, getProject as u, setDevice as v, sameProcessRecord as w, withConfigLock as x, setSupervisor as y };

package/dist/errors-B6W7FkxQ.mjs

@@ -0,0 +1,15 @@
+//#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
+export { supervisorError as n, describeError as t };

package/dist/exec-bsN9MJXb.mjs

@@ -0,0 +1,63 @@
+import { execFileSync, execSync, spawn } from "child_process";
+//#region src/exec.ts
+const MAX_BUFFER = 67108864;
+let active = {
+	run(cmd, { timeoutMs, cwd } = {}) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		if (timeoutMs) opts.timeout = timeoutMs;
+		if (cwd) opts.cwd = cwd;
+		return String(execSync(cmd, opts)).trim();
+	},
+	runFile(file, args = [], { timeoutMs, cwd, env, omitEnv } = {}) {
+		const opts = {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			maxBuffer: MAX_BUFFER
+		};
+		if (timeoutMs) opts.timeout = timeoutMs;
+		if (cwd) opts.cwd = cwd;
+		if (env || omitEnv?.length) {
+			const childEnv = {
+				...process.env,
+				...env
+			};
+			for (const key of omitEnv ?? []) delete childEnv[key];
+			opts.env = childEnv;
+		}
+		return String(execFileSync(file, args, opts)).trim();
+	},
+	runQuiet(cmd, opts) {
+		try {
+			return this.run(cmd, opts);
+		} catch {
+			return null;
+		}
+	},
+	runFileQuiet(file, args, opts) {
+		try {
+			return this.runFile(file, args, opts);
+		} catch {
+			return null;
+		}
+	},
+	spawn(cmd, args = [], opts = {}) {
+		return spawn(cmd, args, opts);
+	}
+};
+function getExecutor() {
+	return active;
+}
+//#endregion
+export { getExecutor as t };