stim 0.0.0 → 1.1.0

package/dist/state-IYEY-zi8.mjs

@@ -0,0 +1,268 @@
+import { D as sameProcessRecord, k as withDirLock, u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { join as join$1, resolve as resolve$1 } from "path";
+import { buildCacheRoot as sharedBuildCache, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+//#region src/paths.ts
+const WORKSPACE_METADATA_FILE_NAME = "workspace.json";
+function workspaceMetadataFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
+}
+function ensureWorkspaceStorage(projectRoot) {
+	const canonicalRoot = resolve$1(projectRoot);
+	const dir = workspaceDir(canonicalRoot);
+	const file = workspaceMetadataFile(canonicalRoot);
+	mkdirSync(dir, { recursive: true });
+	return withDirLock(join$1(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;
+		}
+		try {
+			if (JSON.parse(readFileSync(file, "utf-8")).projectRoot === canonicalRoot) return dir;
+		} catch {}
+		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;
+	});
+}
+function workspaceLogsDir(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "logs");
+}
+function workspaceDerivedData(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "derived-data");
+}
+function supervisorPidFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "supervisor.pid");
+}
+function workspaceStateFile(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "state.json");
+}
+function workspaceStateLock(projectRoot) {
+	return join$1(workspaceDir(projectRoot), "state.lock");
+}
+function supervisorLogFile(projectRoot) {
+	return join$1(workspaceLogsDir(projectRoot), "supervisor.log");
+}
+function emulatorLogFile(projectRoot) {
+	return join$1(workspaceLogsDir(projectRoot), "emulator.log");
+}
+function sharedCompilationCache() {
+	return join$1(getConfigDir(), "compilation-cache");
+}
+function sharedCcache() {
+	return join$1(getConfigDir(), "ccache");
+}
+//#endregion
+//#region src/supervisor/state.ts
+const MODE_BARE = "bare-inproc";
+const MODE_EXPO = "expo-child";
+function readMetroTunnel(root) {
+	const record = readWorkspaceState(root)?.metroTunnel;
+	if (!record || typeof record !== "object") return null;
+	const kind = record.kind;
+	const url = record.url;
+	if (typeof url !== "string" || url.length === 0) return null;
+	if (kind === "expo") return {
+		kind: "expo",
+		url
+	};
+	if (kind === "managed") {
+		const provider = record.provider;
+		const pid = record.pid;
+		const port = record.port;
+		const startedAt = record.startedAt;
+		const processToken = record.processToken;
+		const logFile = record.logFile;
+		if (provider !== "ngrok" && provider !== "cloudflared" || typeof pid !== "number" || typeof port !== "number") return null;
+		return {
+			kind: "managed",
+			provider,
+			pid,
+			url,
+			port,
+			startedAt: typeof startedAt === "string" ? startedAt : "",
+			processToken: typeof processToken === "string" && processToken.length > 0 ? processToken : null,
+			...typeof logFile === "string" && logFile.length > 0 ? { logFile } : {}
+		};
+	}
+	return null;
+}
+function readWorkspaceState(root) {
+	try {
+		const parsed = JSON.parse(readFileSync(workspaceStateFile(root), "utf-8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+function parseWorkspaceLaunchRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	if (typeof record.appId !== "string" || record.appId.length === 0) return null;
+	if (typeof record.deviceId !== "string" || record.deviceId.length === 0) return null;
+	if (record.metroPort !== null && typeof record.metroPort !== "number") return null;
+	if (typeof record.release !== "boolean") return null;
+	if (typeof record.launchedAt !== "string") return null;
+	return record;
+}
+function readWorkspaceLaunches(root) {
+	const launches = readWorkspaceState(root)?.launches;
+	if (!launches || typeof launches !== "object" || Array.isArray(launches)) return {};
+	const ios = parseWorkspaceLaunchRecord(launches.ios);
+	const android = parseWorkspaceLaunchRecord(launches.android);
+	return {
+		...ios ? { ios } : {},
+		...android ? { android } : {}
+	};
+}
+function writeWorkspaceLaunch(root, platform, record) {
+	withWorkspaceStateLock(root, () => {
+		const state = readWorkspaceState(root) ?? {};
+		const launches = state.launches && typeof state.launches === "object" ? state.launches : {};
+		replaceWorkspaceState(root, {
+			...state,
+			launches: {
+				...launches,
+				[platform]: record
+			}
+		});
+	});
+}
+function readRemoteSession(root) {
+	const record = readWorkspaceState(root)?.remoteDevice;
+	if (!record || typeof record !== "object") return null;
+	const id = record.sessionId;
+	if (typeof id !== "string" || id.length === 0) return null;
+	const platform = record.platform;
+	const startedAt = record.startedAt;
+	return {
+		platform: platform === "ios" || platform === "android" ? platform : null,
+		sessionId: id,
+		startedAt: typeof startedAt === "string" ? startedAt : null
+	};
+}
+function readRemoteSessionId(root) {
+	return readRemoteSession(root)?.sessionId ?? null;
+}
+function clearRemoteSession(root, expectedSessionId) {
+	clearWorkspaceStateKey(root, "remoteDevice", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		return value.sessionId === expectedSessionId;
+	});
+}
+function withWorkspaceStateLock(root, fn) {
+	const file = workspaceStateFile(root);
+	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
+		ensureWorkspaceStorage(root);
+		mkdirSync(dirname(file), { recursive: true });
+	} });
+}
+function writeWorkspaceState(root, patch) {
+	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, {
+		...readWorkspaceState(root),
+		...patch
+	}));
+}
+function replaceWorkspaceState(root, state) {
+	const file = workspaceStateFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.tmp-${process.pid}`;
+	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+	renameSync(tmp, file);
+	return state;
+}
+function clearWorkspaceSupervisor(root, expected) {
+	return withWorkspaceStateLock(root, () => {
+		const current = readWorkspaceState(root)?.supervisor;
+		if (current && expected !== void 0 && !sameProcessRecord(current, expected)) return false;
+		clearWorkspaceStateKey(root, "supervisor", () => true);
+		clearExpoMetroTunnel(root);
+		if (expected === void 0 || readPidFile(root) === expected?.pid) rmSync(supervisorPidFile(root), { force: true });
+		return true;
+	});
+}
+function clearExpoMetroTunnel(root) {
+	clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		return typeof value === "object" && value !== null && value.kind === "expo";
+	});
+}
+function clearManagedMetroTunnel(root, expected) {
+	if (!existsSync(workspaceStateFile(root))) return true;
+	return clearWorkspaceStateKey(root, "metroTunnel", (value) => {
+		if (typeof value !== "object" || value === null) return false;
+		const record = value;
+		return record.kind === "managed" && record.provider === expected.provider && record.pid === expected.pid && record.url === expected.url && record.port === expected.port && record.startedAt === expected.startedAt && (record.processToken ?? null) === (expected.processToken ?? null) && (record.logFile ?? null) === (expected.logFile ?? null);
+	});
+}
+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 writePidFile(root, pid) {
+	const file = supervisorPidFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, `${pid}\n`);
+	return file;
+}
+function readPidFile(root) {
+	try {
+		const pid = parseInt(readFileSync(supervisorPidFile(root), "utf-8").trim(), 10);
+		return Number.isFinite(pid) ? pid : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { supervisorLogFile as C, workspaceLogsDir as D, workspaceId as E, workspaceName$1 as O, sharedCompilationCache as S, workspaceDir as T, writeWorkspaceState as _, clearRemoteSession as a, sharedBuildCache as b, readMetroTunnel as c, readRemoteSessionId as d, readWorkspaceLaunches as f, writeWorkspaceLaunch as g, writePidFile as h, clearManagedMetroTunnel as i, workspaceStateFile as k, readPidFile as l, withWorkspaceStateLock as m, MODE_EXPO as n, clearWorkspaceStateKeys as o, readWorkspaceState as p, clearExpoMetroTunnel as r, clearWorkspaceSupervisor as s, MODE_BARE as t, readRemoteSession as u, emulatorLogFile as v, workspaceDerivedData as w, sharedCcache as x, ensureWorkspaceStorage as y };

package/dist/stats-DZ4Q5J-7.mjs

@@ -0,0 +1,62 @@
+import { g as repoRoot, s as gitCommonDir } from "./worktree-Dx3ZC5lS.mjs";
+import { a as findProjectRoot } from "./project-COj6nzzh.mjs";
+import { o as formatLongDuration } from "./command-output-8wHMEde0.mjs";
+import { a as statsProjectKey, r as readStats } from "./stats-wqxPm7Tv.mjs";
+import chalk from "chalk";
+//#region src/commands/stats.ts
+const PLATFORMS = ["ios", "android"];
+const PLATFORM_WIDTH = 9;
+function statsCommand(program) {
+	program.command("stats").description("Show how many `ios` and `android` runs this project and this machine have recorded, how many hit the build cache, and an estimate of the time that cache saved.").option("--json", "print the aggregates as JSON").action((opts) => {
+		const root = findProjectRoot(process.cwd());
+		const key = root ? statsProjectKey({
+			root,
+			commonDir: gitCommonDir(root),
+			repoRoot: repoRoot(root)
+		}) : null;
+		const { record, note } = readStats();
+		if (note) console.error(chalk.dim(note));
+		const machine = record?.machine ?? {};
+		const project = key ? record?.projects?.[key] ?? {} : {};
+		if (opts.json) {
+			console.log(JSON.stringify({
+				version: 1,
+				project: key ? {
+					key,
+					ios: project.ios ?? null,
+					android: project.android ?? null
+				} : null,
+				machine: {
+					ios: machine.ios ?? null,
+					android: machine.android ?? null
+				}
+			}));
+			return;
+		}
+		const lines = [];
+		if (key) lines.push(`project ${key}`, ...sectionLines(project));
+		lines.push("machine", ...sectionLines(machine));
+		for (const line of lines) console.log(line);
+	});
+}
+function sectionLines(scope) {
+	const lines = PLATFORMS.filter((platform) => scope[platform]).map((platform) => bucketLine(platform, scope[platform]));
+	return lines.length ? lines : [chalk.dim("  no runs recorded")];
+}
+function bucketLine(platform, bucket) {
+	const finished = bucket.runs - bucket.failed;
+	const cells = [
+		`${bucket.runs} runs${bucket.failed > 0 ? ` (${bucket.failed} failed)` : ""}`,
+		`${bucket.hits} hits (${finished > 0 ? `${Math.round(bucket.hits / finished * 100)}%` : "-"})`,
+		`cold run ${average(bucket.coldRunMs, bucket.coldRuns)} avg`,
+		`hit run ${average(bucket.hitRunMs, bucket.hitRuns)} avg`,
+		`saved ~${formatLongDuration(bucket.timeSavedMs)} (estimated)`,
+		`since ${bucket.firstRunAt.slice(0, 10)}`
+	];
+	return `  ${platform.padEnd(PLATFORM_WIDTH)}${cells.join("   ")}`;
+}
+function average(totalMs, runs) {
+	return runs > 0 ? formatLongDuration(Math.round(totalMs / runs)) : "-";
+}
+//#endregion
+export { statsCommand as default };

package/dist/stats-wqxPm7Tv.mjs

@@ -0,0 +1,307 @@
+import { C as withConfigLock, u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+const PLATFORMS = ["ios", "android"];
+function statsFile() {
+	return join(getConfigDir(), "stats.json");
+}
+function emptyStats() {
+	return {
+		version: 1,
+		machine: {},
+		projects: {}
+	};
+}
+function statsProjectKey({ root, commonDir, repoRoot }) {
+	if (commonDir && repoRoot && basename(commonDir) === ".git") return canonical(join(dirname(commonDir), relative(repoRoot, root)));
+	return canonical(root);
+}
+function updateStats(record, run, now) {
+	const at = new Date(now).toISOString();
+	const durationMs = wholeMs(run.durationMs);
+	const phases = {
+		coldBuildMs: wholeMs(run.coldBuildMs),
+		podsMs: wholeMs(run.podsMs)
+	};
+	const projects = { ...record.projects };
+	const scope = { ...projects[run.projectKey] };
+	const machine = { ...record.machine };
+	const before = scope[run.platform] ?? null;
+	const credit = creditMs(before, run, durationMs);
+	scope[run.platform] = applyRun(before, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	projects[run.projectKey] = scope;
+	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	return {
+		version: 1,
+		machine,
+		projects
+	};
+}
+function readStats() {
+	const path = statsFile();
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return {
+			record: null,
+			note: null
+		};
+	}
+	const parsed = parseRecord(text);
+	if (!parsed) return {
+		record: null,
+		note: `Run statistics at ${path} could not be read; the next ios or android run moves them aside and starts a new file.`
+	};
+	if (parsed.version > 1) return {
+		record: null,
+		note: `Run statistics at ${path} are version ${parsed.version}, which this Stim does not understand, so none are shown.`
+	};
+	return {
+		record: normalize(parsed),
+		note: null
+	};
+}
+function projectEstimates(record, projectKey, platform) {
+	const bucket = record?.projects?.[projectKey]?.[platform] ?? null;
+	return {
+		coldBuildMs: positive(bucket?.lastColdBuildMs),
+		podsMs: positive(bucket?.lastPodsMs)
+	};
+}
+function readRunEstimates({ projectKey, platform, read = readStats }) {
+	if (!projectKey) return {
+		coldBuildMs: null,
+		podsMs: null
+	};
+	try {
+		return projectEstimates(read().record, projectKey, platform);
+	} catch {
+		return {
+			coldBuildMs: null,
+			podsMs: null
+		};
+	}
+}
+function recordRunStats(run, now) {
+	return withConfigLock(() => {
+		const path = statsFile();
+		const loaded = loadForUpdate(path, now);
+		if (loaded.newerVersion !== null) return {
+			recorded: false,
+			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
+		};
+		writeStats(path, updateStats(loaded.record, run, now));
+		return {
+			recorded: true,
+			note: loaded.note
+		};
+	});
+}
+function createRunRecorder({ platform, write, now, note }) {
+	let projectKey = null;
+	let cacheKey = null;
+	let coldBuildMs = 0;
+	let podsMs = 0;
+	let recorded = false;
+	return {
+		setProject(key) {
+			projectKey = key;
+		},
+		setCacheKey(key) {
+			cacheKey = key;
+		},
+		setBuildMs(ms) {
+			coldBuildMs = wholeMs(ms);
+		},
+		setPodsMs(ms) {
+			podsMs = wholeMs(ms);
+		},
+		record({ failed, cacheHit = false, waited = null, durationMs }) {
+			if (!projectKey || !cacheKey || recorded) return;
+			recorded = true;
+			try {
+				const outcome = write({
+					platform,
+					projectKey,
+					failed,
+					cacheHit,
+					waitedForBuild: Boolean(waited),
+					durationMs,
+					...coldBuildMs > 0 ? { coldBuildMs } : {},
+					...podsMs > 0 ? { podsMs } : {}
+				}, now());
+				if (outcome?.note) note(outcome.note);
+			} catch (error) {
+				note(`Run statistics could not be recorded: ${error?.message || error}`);
+			}
+		}
+	};
+}
+function loadForUpdate(path, now) {
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return {
+			record: emptyStats(),
+			note: null,
+			newerVersion: null
+		};
+	}
+	const parsed = parseRecord(text);
+	if (!parsed) {
+		const aside = `${path}.corrupt-${now}`;
+		renameSync(path, aside);
+		return {
+			record: emptyStats(),
+			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
+			newerVersion: null
+		};
+	}
+	if (parsed.version > 1) return {
+		record: emptyStats(),
+		note: null,
+		newerVersion: parsed.version
+	};
+	return {
+		record: normalize(parsed),
+		note: null,
+		newerVersion: null
+	};
+}
+function writeStats(path, record) {
+	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
+	try {
+		renameSync(tmp, path);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function parseRecord(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const version = parsed.version;
+	if (typeof version !== "number" || !Number.isInteger(version)) return null;
+	return parsed;
+}
+function normalize(record) {
+	const projects = {};
+	const source = record.projects;
+	if (source && typeof source === "object" && !Array.isArray(source)) for (const [key, scope] of Object.entries(source)) projects[key] = normalizeScope(scope);
+	return {
+		version: 1,
+		machine: normalizeScope(record.machine),
+		projects
+	};
+}
+function normalizeScope(scope) {
+	const normalized = {};
+	if (!scope || typeof scope !== "object" || Array.isArray(scope)) return normalized;
+	for (const platform of PLATFORMS) {
+		const bucket = scope[platform];
+		if (bucket && typeof bucket === "object" && !Array.isArray(bucket)) normalized[platform] = normalizeBucket(bucket);
+	}
+	return normalized;
+}
+function normalizeBucket(bucket) {
+	return {
+		runs: count(bucket.runs),
+		failed: count(bucket.failed),
+		hits: count(bucket.hits),
+		misses: count(bucket.misses),
+		coldRuns: count(bucket.coldRuns),
+		coldRunMs: count(bucket.coldRunMs),
+		hitRuns: count(bucket.hitRuns),
+		hitRunMs: count(bucket.hitRunMs),
+		timeSavedMs: count(bucket.timeSavedMs),
+		firstRunAt: timestamp(bucket.firstRunAt),
+		lastRunAt: timestamp(bucket.lastRunAt),
+		...count(bucket.lastColdBuildMs) > 0 ? { lastColdBuildMs: count(bucket.lastColdBuildMs) } : {},
+		...count(bucket.lastPodsMs) > 0 ? { lastPodsMs: count(bucket.lastPodsMs) } : {}
+	};
+}
+function applyRun(bucket, run, { at, durationMs, credit, phases }) {
+	const next = bucket ? { ...bucket } : {
+		runs: 0,
+		failed: 0,
+		hits: 0,
+		misses: 0,
+		coldRuns: 0,
+		coldRunMs: 0,
+		hitRuns: 0,
+		hitRunMs: 0,
+		timeSavedMs: 0,
+		firstRunAt: at,
+		lastRunAt: at
+	};
+	next.runs += 1;
+	next.lastRunAt = at;
+	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
+	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
+	if (run.failed) {
+		next.failed += 1;
+		return next;
+	}
+	if (isHit(run.cacheHit)) {
+		next.hits += 1;
+		if (!run.waitedForBuild) {
+			next.hitRuns += 1;
+			next.hitRunMs += durationMs;
+			next.timeSavedMs += credit;
+		}
+		return next;
+	}
+	next.misses += 1;
+	next.coldRuns += 1;
+	next.coldRunMs += durationMs;
+	return next;
+}
+function creditMs(bucket, run, durationMs) {
+	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
+	if (!bucket || bucket.coldRuns <= 0) return 0;
+	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
+}
+function isHit(cacheHit) {
+	return cacheHit === "local" || cacheHit === "remote";
+}
+function positive(value) {
+	const ms = wholeMs(value);
+	return ms > 0 ? ms : null;
+}
+function wholeMs(value) {
+	const ms = Number(value);
+	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
+}
+function count(value) {
+	return wholeMs(value);
+}
+function timestamp(value) {
+	return typeof value === "string" && value !== "" ? value : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return resolve(path);
+	}
+}
+//#endregion
+export { statsProjectKey as a, recordRunStats as i, readRunEstimates as n, readStats as r, createRunRecorder as t };