stim 1.0.0 → 1.1.0

package/dist/{state-2nush3MK.mjs → state-IYEY-zi8.mjs}

@@ -1,23 +1,23 @@
-import { E as withDirLock, l as getConfigDir, w as sameProcessRecord } from "./config-7kmtuhO2.mjs";
+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 { join, resolve } from "path";
-import { buildCacheRoot as sharedBuildCache, workspaceName, workspaceStateDir as workspaceDir } from "@stim-cli/core";
-import { dirname as dirname$1 } from "node:path";
+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(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
+	return join$1(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
 }
 function ensureWorkspaceStorage(projectRoot) {
-	const canonicalRoot = resolve(projectRoot);
+	const canonicalRoot = resolve$1(projectRoot);
 	const dir = workspaceDir(canonicalRoot);
 	const file = workspaceMetadataFile(canonicalRoot);
 	mkdirSync(dir, { recursive: true });
-	return withDirLock(join(dir, "metadata.lock"), () => {
+	return withDirLock(join$1(dir, "metadata.lock"), () => {
 		if (!existsSync(file)) {
 			const metadata = {
 				projectRoot: canonicalRoot,
-				workspace: workspaceName(canonicalRoot),
+				workspace: workspaceName$1(canonicalRoot),
 				version: 1
 			};
 			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
@@ -39,31 +39,31 @@ function ensureWorkspaceStorage(projectRoot) {
 	});
 }
 function workspaceLogsDir(projectRoot) {
-	return join(workspaceDir(projectRoot), "logs");
+	return join$1(workspaceDir(projectRoot), "logs");
 }
 function workspaceDerivedData(projectRoot) {
-	return join(workspaceDir(projectRoot), "derived-data");
+	return join$1(workspaceDir(projectRoot), "derived-data");
 }
 function supervisorPidFile(projectRoot) {
-	return join(workspaceDir(projectRoot), "supervisor.pid");
+	return join$1(workspaceDir(projectRoot), "supervisor.pid");
 }
 function workspaceStateFile(projectRoot) {
-	return join(workspaceDir(projectRoot), "state.json");
+	return join$1(workspaceDir(projectRoot), "state.json");
 }
 function workspaceStateLock(projectRoot) {
-	return join(workspaceDir(projectRoot), "state.lock");
+	return join$1(workspaceDir(projectRoot), "state.lock");
 }
 function supervisorLogFile(projectRoot) {
-	return join(workspaceLogsDir(projectRoot), "supervisor.log");
+	return join$1(workspaceLogsDir(projectRoot), "supervisor.log");
 }
 function emulatorLogFile(projectRoot) {
-	return join(workspaceLogsDir(projectRoot), "emulator.log");
+	return join$1(workspaceLogsDir(projectRoot), "emulator.log");
 }
 function sharedCompilationCache() {
-	return join(getConfigDir(), "compilation-cache");
+	return join$1(getConfigDir(), "compilation-cache");
 }
 function sharedCcache() {
-	return join(getConfigDir(), "ccache");
+	return join$1(getConfigDir(), "ccache");
 }
 //#endregion
 //#region src/supervisor/state.ts
@@ -116,7 +116,6 @@ function parseWorkspaceLaunchRecord(value) {
 	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 (record.deepLinkUrl !== null && typeof record.deepLinkUrl !== "string") return null;
 	if (typeof record.launchedAt !== "string") return null;
 	return record;
 }
@@ -169,7 +168,7 @@ function withWorkspaceStateLock(root, fn) {
 	const file = workspaceStateFile(root);
 	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
 		ensureWorkspaceStorage(root);
-		mkdirSync(dirname$1(file), { recursive: true });
+		mkdirSync(dirname(file), { recursive: true });
 	} });
 }
 function writeWorkspaceState(root, patch) {
@@ -180,7 +179,7 @@ function writeWorkspaceState(root, patch) {
 }
 function replaceWorkspaceState(root, state) {
 	const file = workspaceStateFile(root);
-	mkdirSync(dirname$1(file), { recursive: true });
+	mkdirSync(dirname(file), { recursive: true });
 	const tmp = `${file}.tmp-${process.pid}`;
 	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
 	renameSync(tmp, file);
@@ -253,7 +252,7 @@ function clearWorkspaceStateKey(root, key, shouldClear) {
 }
 function writePidFile(root, pid) {
 	const file = supervisorPidFile(root);
-	mkdirSync(dirname$1(file), { recursive: true });
+	mkdirSync(dirname(file), { recursive: true });
 	writeFileSync(file, `${pid}\n`);
 	return file;
 }
@@ -266,4 +265,4 @@ function readPidFile(root) {
 	}
 }
 //#endregion
-export { supervisorLogFile as C, workspaceName as D, workspaceLogsDir as E, workspaceStateFile 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, 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 };
+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 };