stim 1.9.0 → 1.10.1

package/dist/guide-status-CWvti2Lg.mjs

@@ -0,0 +1,125 @@
+import { f as getProject, u as getConfigDir, w as upsertProject } from "./config-BEq0Qw_a.mjs";
+import { n as appProjectProblem } from "./project-BXZzOABt.mjs";
+import { t as compareStimVersions } from "./stim-installations-CINXy_su.mjs";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/guide-status.ts
+const DAY_MS = 864e5;
+const DOCTOR_STALE_MS = 7 * DAY_MS;
+const UPDATE_CHECK_INTERVAL_MS = DAY_MS;
+const UPDATE_CHECK_TIMEOUT_MS = 2e3;
+const LATEST_URL = "https://registry.npmjs.org/stim/latest";
+const PLATFORMS = ["ios", "android"];
+function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date()) {
+	const run = {
+		at: now.toISOString(),
+		version
+	};
+	try {
+		if (appProjectProblem(projectRoot)) return;
+		upsertProject(projectRoot, (existing) => {
+			const doctorRuns = { ...existing.doctorRuns };
+			for (const target of platform ? [platform] : PLATFORMS) doctorRuns[target] = run;
+			return { doctorRuns };
+		});
+	} catch {}
+}
+function doctorDueReason(record, running, now) {
+	const at = record ? Date.parse(record.at) : NaN;
+	if (!record || Number.isNaN(at)) return "never run";
+	if (record.version !== running) return `last run with stim ${record.version}`;
+	const age = now.getTime() - at;
+	if (age > DOCTOR_STALE_MS) return `last run ${Math.floor(age / DAY_MS)} days ago`;
+	return null;
+}
+function updateCacheFile() {
+	return join(getConfigDir(), "update-check.json");
+}
+function readUpdateCache() {
+	try {
+		const parsed = JSON.parse(readFileSync(updateCacheFile(), "utf-8"));
+		if (typeof parsed?.checkedAt !== "string") return null;
+		return {
+			checkedAt: parsed.checkedAt,
+			latest: typeof parsed.latest === "string" ? parsed.latest : null
+		};
+	} catch {
+		return null;
+	}
+}
+function writeUpdateCache(cache) {
+	const target = updateCacheFile();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		mkdirSync(getConfigDir(), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(cache)}\n`);
+		renameSync(tmp, target);
+	} catch {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+	}
+}
+async function fetchLatest(fetchImpl) {
+	const res = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
+	if (!res.ok) return null;
+	const body = await res.json();
+	return typeof body.version === "string" ? body.version : null;
+}
+async function checkForUpdate(running, { now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch } = {}) {
+	if (process.env.STIM_NO_UPDATE_CHECK) return null;
+	const cached = readUpdateCache();
+	const checkedAt = cached ? Date.parse(cached.checkedAt) : NaN;
+	let latest = cached?.latest ?? null;
+	if (Number.isNaN(checkedAt) || now.getTime() - checkedAt > UPDATE_CHECK_INTERVAL_MS) {
+		try {
+			latest = await fetchLatest(fetchImpl);
+		} catch {
+			latest = null;
+		}
+		writeUpdateCache({
+			checkedAt: now.toISOString(),
+			latest
+		});
+	}
+	if (!latest) return null;
+	const comparison = compareStimVersions(latest, running);
+	return comparison !== null && comparison > 0 ? latest : null;
+}
+function renderGuideStatus({ running, doctor, latest }) {
+	const lines = [];
+	if (doctor.length) {
+		const named = doctor.map((due) => `${due.platform} (${due.reason})`).join(" and ");
+		const command = doctor.length === 1 ? `stim doctor --platform ${doctor[0]?.platform}` : "stim doctor";
+		lines.push(`  Doctor is due for ${named}.`, `  Run before native work:  ${command}`);
+	}
+	if (latest) lines.push(`  stim ${latest} is available (running ${running}):  npm install -g stim@latest`);
+	if (!lines.length) return null;
+	return ["STATUS", ...lines].join("\n");
+}
+async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
+	const doctor = [];
+	if (projectRoot && !appProjectProblem(projectRoot)) {
+		let runs = null;
+		try {
+			runs = getProject(projectRoot)?.doctorRuns ?? {};
+		} catch {}
+		if (runs) for (const platform of PLATFORMS) {
+			const reason = doctorDueReason(runs[platform], running, now);
+			if (reason) doctor.push({
+				platform,
+				reason
+			});
+		}
+	}
+	return renderGuideStatus({
+		running,
+		doctor,
+		latest: await checkForUpdate(running, {
+			now,
+			fetch: fetchImpl
+		})
+	});
+}
+//#endregion
+export { recordDoctorRun as n, guideStatus as t };

package/dist/idle--jn7pBNe.mjs

@@ -0,0 +1,157 @@
+import { H as projectDeviceSlots } from "./config-BEq0Qw_a.mjs";
+import { m as readWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { o as formatLongDuration } from "./command-output-D5z2_bcF.mjs";
+import { c as createActivityReader, l as idleForMs, o as parseActiveBuild, r as activeBuildState, t as ACTIVE_BUILD_KEY } from "./build-progress-BXx-ZBe4.mjs";
+import { N as ownedAvdSerialResolver } from "./android-787HhP5w.mjs";
+import { d as teardownOwnedAvd, f as teardownOwnedIosSim } from "./ownership-BfPNRf3-.mjs";
+import chalk from "chalk";
+//#region src/commands/gc/idle.ts
+function findOwnedDeviceActivity({ config, sims, androidSerial, readActivity, deadProjects = [] }) {
+	const booted = new Map(sims.filter((sim) => sim.state === "Booted").map((sim) => [sim.udid, sim.name]));
+	const dead = new Set(deadProjects);
+	const found = [];
+	for (const [project, record] of Object.entries(config?.projects ?? {})) {
+		if (dead.has(project)) continue;
+		for (const { slot, platforms } of projectDeviceSlots(record)) {
+			const ios = platforms.ios;
+			if (ios?.owned && ios.deviceUdid && booted.has(ios.deviceUdid)) found.push({
+				kind: "ios",
+				id: ios.deviceUdid,
+				name: booted.get(ios.deviceUdid) ?? ios.deviceUdid,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "ios",
+					id: ios.deviceUdid,
+					slot,
+					workspace: project
+				})
+			});
+			const android = platforms.android;
+			const serial = android?.owned && android.avdName ? androidSerial(android.avdName) : null;
+			if (android?.avdName && serial) found.push({
+				kind: "android",
+				id: android.avdName,
+				name: android.avdName,
+				project,
+				slot,
+				activity: readActivity({
+					platform: "android",
+					id: serial,
+					slot,
+					workspace: project
+				})
+			});
+		}
+	}
+	return found;
+}
+function findIdleDevices({ buildInProgress, now, ...inputs }) {
+	return findOwnedDeviceActivity(inputs).filter((device) => device.activity.state === "idle").map(({ kind, id, name, project, slot, activity }) => ({
+		kind,
+		id,
+		name,
+		project,
+		slot,
+		lastActivityAt: activity.lastActivityAt ?? null,
+		idleForMs: idleForMs(activity, now),
+		buildInProgress: buildInProgress(project)
+	}));
+}
+function idleShutdownCandidates(devices, idleMs) {
+	return devices.filter((d) => !d.buildInProgress && d.idleForMs !== null && d.idleForMs >= idleMs);
+}
+function parseIdleDuration(value) {
+	const match = /^([1-9][0-9]*)(m|h|d)$/.exec(value.trim());
+	if (!match) return null;
+	const unit = {
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	return Number(match[1]) * unit;
+}
+function workspaceBuildInProgress(project) {
+	const record = parseActiveBuild(readWorkspaceState(project)?.[ACTIVE_BUILD_KEY]);
+	if (!record) return false;
+	try {
+		return activeBuildState(record.claim) !== "stale";
+	} catch {
+		return true;
+	}
+}
+function deviceActivityInputs(config, sims, now) {
+	const resolve = ownedAvdSerialResolver({ timeoutMs: 5e3 });
+	return {
+		config,
+		sims,
+		readActivity: createActivityReader({ now }),
+		androidSerial: (avdName) => {
+			try {
+				return resolve(avdName).serial ?? null;
+			} catch {
+				return null;
+			}
+		}
+	};
+}
+function collectOwnedDeviceActivity(config, sims, now = Date.now()) {
+	return findOwnedDeviceActivity(deviceActivityInputs(config, sims, now));
+}
+function collectIdleDevices(config, sims, deadProjects, now = Date.now()) {
+	return findIdleDevices({
+		...deviceActivityInputs(config, sims, now),
+		deadProjects,
+		now,
+		buildInProgress: workspaceBuildInProgress
+	});
+}
+function idleDeviceLines(devices) {
+	if (devices.length === 0) return [];
+	return [`Idle owned devices (${devices.length}) - booted with no driver, claim, or recent activity:`, ...devices.map((d) => {
+		const slot = d.slot === "default" ? "" : ` [${d.slot}]`;
+		const idle = d.idleForMs === null ? "idle for an unknown time" : `idle ${formatLongDuration(d.idleForMs)}`;
+		const build = d.buildInProgress ? ", build in progress" : "";
+		return `  ${d.kind}${slot} ${d.name} (${d.project}) -- ${idle}${build}`;
+	})];
+}
+function shutDownIdleDevices(devices, idleMs, recollect) {
+	const candidates = idleShutdownCandidates(devices, idleMs);
+	const shutDown = [];
+	if (candidates.length === 0) {
+		console.log(chalk.dim(`No owned device has been idle for ${formatLongDuration(idleMs)} or more.`));
+		return {
+			failures: 0,
+			shutDown
+		};
+	}
+	const fresh = idleShutdownCandidates(recollect(), idleMs);
+	let failures = 0;
+	for (const device of candidates) {
+		const what = `${device.kind} ${device.name}`;
+		const current = fresh.find((d) => d.kind === device.kind && d.id === device.id && d.project === device.project && d.slot === device.slot);
+		if (!current) {
+			console.log(chalk.dim(`Kept ${what}: it is no longer idle for ${formatLongDuration(idleMs)}.`));
+			continue;
+		}
+		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, { label: device.name }) : teardownOwnedAvd(device.id, { owner: {
+			projectPath: device.project,
+			slot: device.slot
+		} });
+		if (outcome.status === "torn-down") {
+			shutDown.push(device);
+			console.log(chalk.green(`Shut down ${what}, idle ${formatLongDuration(current.idleForMs)}`));
+		} else if (outcome.status === "missing") console.log(chalk.dim(`${what} is already gone; nothing to shut down.`));
+		else if (outcome.status === "skipped") console.log(chalk.yellow(`Skipped ${what}: ${outcome.reason}`));
+		else {
+			failures++;
+			console.log(chalk.red(`Failed to shut down ${what}: ${outcome.reason}`));
+		}
+	}
+	return {
+		failures,
+		shutDown
+	};
+}
+//#endregion
+export { parseIdleDuration as a, idleShutdownCandidates as i, collectOwnedDeviceActivity as n, shutDownIdleDevices as o, idleDeviceLines as r, workspaceBuildInProgress as s, collectIdleDevices as t };

package/dist/in-use-CNIWU-r-.mjs

@@ -0,0 +1,245 @@
+import { f as getProject, k as ownership_claim_exports, u as getConfigDir } from "./config-BEq0Qw_a.mjs";
+import { O as workspaceDir, m as readWorkspaceState } from "./metro-BWLOJ_Wr.mjs";
+import { r as stopDeclaringSpawnsOn, t as declareSpawnsOn } from "./spawn-claims-CUleC2cM.mjs";
+import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-BXA96myD.mjs";
+import { a as formatElapsed } from "./command-output-D5z2_bcF.mjs";
+import { h as listBuildLocks } from "./device-lease-CbEaIk7b.mjs";
+import { n as managedLockHolders, t as resolveSupervisorTarget } from "./ownership-BfPNRf3-.mjs";
+import { lstatSync, readdirSync, rmSync, rmdirSync, statSync, unlinkSync } from "node:fs";
+import { realpathSync as realpathSync$1 } from "fs";
+import { resolve } from "path";
+import { join as join$1 } from "node:path";
+//#region src/engine/build-slots.ts
+const SLOT_PREFIX = "slot-";
+const SLOT_LABEL = "build slot";
+const SLOT_POLL_MS = 1e3;
+const SLOT_PROGRESS_MS = 3e4;
+const SLOT_CEILING_MS = 54e5;
+function sleepAsync(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildSlotsDir() {
+	return join$1(getConfigDir(), "build-slots");
+}
+function buildSlotPath(index) {
+	return join$1(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
+}
+function toRecord(holder) {
+	const details = holder.details;
+	return {
+		pid: holder.owner.pid,
+		index: typeof details.index === "number" ? details.index : null,
+		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
+		startedAt: holder.startedAt || null,
+		logFile: typeof details.logFile === "string" ? details.logFile : null
+	};
+}
+function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	let refusal = null;
+	let busy = false;
+	for (let index = 0; index < max; index++) {
+		const path = buildSlotPath(index);
+		let attempt;
+		try {
+			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+				root: path,
+				mode: "exclusive",
+				label: SLOT_LABEL,
+				details: {
+					index,
+					projectRoot: root,
+					logFile
+				}
+			});
+		} catch (err) {
+			if (!(0, ownership_claim_exports.isClaimRefusal)(err)) throw err;
+			refusal ??= err;
+			continue;
+		}
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		if (!attempt.acquired) {
+			busy = true;
+			continue;
+		}
+		declareSpawnsOn(attempt.acquired);
+		return {
+			acquired: true,
+			path,
+			index,
+			slot: {
+				pid: attempt.acquired.owner.pid,
+				index,
+				projectRoot: root,
+				startedAt: attempt.acquired.startedAt,
+				logFile
+			},
+			claim: attempt.acquired
+		};
+	}
+	if (refusal && !busy) throw refusal;
+	return null;
+}
+function slotWaitingLine({ max, elapsedMs }) {
+	return `${"build".padEnd(11)} waiting for a build slot (all ${max} in use, ${formatElapsed(elapsedMs)} elapsed) -- stim guide lifecycle concurrency`;
+}
+async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.now, out = () => {}, sleep = sleepAsync, intervalMs = SLOT_POLL_MS, progressMs = SLOT_PROGRESS_MS, ceilingMs = SLOT_CEILING_MS }) {
+	if (!max || max <= 0) return {
+		acquired: true,
+		unlimited: true
+	};
+	const started = now();
+	let lastProgress = started;
+	for (;;) {
+		const got = tryAcquireBuildSlot({
+			max,
+			root,
+			logFile
+		});
+		if (got) return got;
+		const elapsed = now() - started;
+		if (elapsed >= ceilingMs) {
+			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for one of ${max} build slots, and every slot is held by a process that is still running, or by a holder Stim cannot identify. Slots live under ` + buildSlotsDir() + "; remove a slot directory whose builder is not really building, or raise concurrency.maxBuilds.");
+			err.code = "STIM_BUILD_SLOT_TIMEOUT";
+			throw err;
+		}
+		if (now() - lastProgress >= progressMs) {
+			lastProgress = now();
+			out(slotWaitingLine({
+				max,
+				elapsedMs: elapsed
+			}));
+		}
+		await sleep(intervalMs);
+	}
+}
+function releaseBuildSlot(handle) {
+	if (!handle || handle.unlimited) return false;
+	stopDeclaringSpawnsOn(handle.claim);
+	return (0, ownership_claim_exports.releaseClaim)(handle.claim);
+}
+function listBuildSlots() {
+	const dir = buildSlotsDir();
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const slots = [];
+	for (const name of names) {
+		if (!name.startsWith(SLOT_PREFIX)) continue;
+		const path = join$1(dir, name);
+		try {
+			if (!statSync(path).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const survey = (0, ownership_claim_exports.readClaimSet)(path);
+		const holder = survey.live[0] ?? survey.dead[0];
+		const info = holder ? toRecord(holder) : null;
+		const index = Number(name.slice(5));
+		slots.push({
+			path,
+			name,
+			index: Number.isFinite(index) ? index : null,
+			pid: info?.pid ?? null,
+			projectRoot: info?.projectRoot ?? null,
+			startedAt: info?.startedAt ?? null,
+			logFile: info?.logFile ?? null,
+			alive: survey.live.length > 0,
+			unresolved: survey.unresolved.length > 0
+		});
+	}
+	return slots;
+}
+//#endregion
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return resolve(p);
+	}
+}
+//#endregion
+//#region src/workspace/in-use.ts
+const NATIVE_RUN = "native-run";
+const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
+function workspaceInUse(root, { supervisor = true, managedLocks = true, nativeRun = true } = {}) {
+	const reasons = [];
+	if (supervisor) {
+		const project = getProject(root);
+		const target = resolveSupervisorTarget({
+			state: readWorkspaceState(root)?.supervisor,
+			record: project?.supervisor,
+			reservedPort: project?.metroPort
+		});
+		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
+		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+	}
+	if (nativeRun) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
+		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
+		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	const self = canonicalPath(root);
+	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
+		if (!entry.alive && !entry.unresolved) continue;
+		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
+	}
+	if (managedLocks) reasons.push(...managedLockHolders(root));
+	return reasons;
+}
+function emptyWorkspaceDir(dir) {
+	if (lstatSync(dir).isSymbolicLink()) {
+		unlinkSync(dir);
+		return;
+	}
+	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join$1(dir, name), {
+		recursive: true,
+		force: true
+	});
+}
+async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
+			const reasons = workspaceInUse(root, {
+				...checks,
+				nativeRun: false
+			});
+			if (reasons.length) return {
+				ran: false,
+				reasons
+			};
+			return {
+				ran: true,
+				value: await fn()
+			};
+		}, {
+			external: true,
+			waitMs: 0,
+			ownerPurpose: purpose
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error)) return {
+			ran: false,
+			reasons: [NATIVE_RUN_HELD]
+		};
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
+			ran: false,
+			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
+		};
+		throw error;
+	} finally {
+		try {
+			const dir = workspaceDir(root);
+			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
+		} catch {}
+	}
+}
+//#endregion
+export { acquireBuildSlot as a, canonicalPath as i, withIdleWorkspace as n, listBuildSlots as o, workspaceInUse as r, releaseBuildSlot as s, emptyWorkspaceDir as t };