stim 0.0.0 → 1.1.0

package/dist/status-Dia0XTqG.mjs

@@ -0,0 +1,363 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { P as volumeRootFor, g as loadConfig, u as getConfigDir } from "./config-D7uu8Gbq.mjs";
+import { D as workspaceLogsDir } from "./state-IYEY-zi8.mjs";
+import { f as listWorktrees } from "./worktree-Dx3ZC5lS.mjs";
+import { a as findProjectRoot, c as projectShortcut } from "./project-COj6nzzh.mjs";
+import { a as isMetroRunning, i as resolveProjectMetro } from "./metro-B01H3EuD.mjs";
+import { S as readParked, v as POOL_SETTING_REMEDY, x as parkedMaxSetting } from "./remote-cache-DOi5-zLj.mjs";
+import { a as formatElapsed, r as clockTime, u as plural } from "./command-output-8wHMEde0.mjs";
+import { l as listAllIosSims } from "./ios-BZxKPuqP.mjs";
+import { i as listLeaseFiles } from "./device-lease-D-G3SgVe.mjs";
+import { s as queryLogs } from "./logs-query-oqn47Ffx.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-B9QIdQOw.mjs";
+import { i as readSupervisorState } from "./stop-BApyaF21.mjs";
+import { existsSync } from "fs";
+import { totalmem } from "os";
+import chalk from "chalk";
+//#region src/status.ts
+const IOS_SIM_MB = 1500;
+const ANDROID_EMULATOR_MB = 2500;
+const METRO_MB = 700;
+function poolLine({ platform, parked, max }) {
+	if (parked <= 0) return null;
+	const what = plural(parked, `parked ${platform === "ios" ? "iOS simulator" : "Android emulator"}`);
+	return max > 0 ? `pool: ${what} (max ${max})` : `pool: ${what} (parking off; gc --delete removes them)`;
+}
+function environmentState(project, { simsByUdid = {}, metro = null, worktrees = [], simsAvailable = true, supervisor = null, logs = null } = {}) {
+	const ios = project.platforms?.ios;
+	const android = project.platforms?.android;
+	const sim = ios ? simsByUdid[ios.deviceUdid] : null;
+	const simBooted = Boolean(sim && sim.state === "Booted");
+	const metroRunning = Boolean(metro?.metro);
+	const live = simBooted || metroRunning || Boolean(android?.serial);
+	let memoryMb = 0;
+	if (simBooted) memoryMb += IOS_SIM_MB;
+	if (android?.serial) memoryMb += ANDROID_EMULATOR_MB;
+	if (metroRunning) memoryMb += METRO_MB;
+	const warnings = [];
+	if (metro?.notOurs) warnings.push(`port ${project.metroPort}: ${metro.notOurs}`);
+	if (ios && !sim && simsAvailable) warnings.push(`recorded sim ${ios.deviceUdid} no longer exists`);
+	if (simBooted && project.metroPort && !metroRunning) warnings.push("simulator is booted with no Metro serving it");
+	if (supervisor && supervisor.alive === false) warnings.push(`stale supervisor record for ${project.__path}`);
+	return {
+		path: project.__path,
+		live,
+		memoryMb,
+		warnings,
+		ios: ios ? {
+			name: sim?.name ?? null,
+			udid: ios.deviceUdid,
+			owned: Boolean(ios.owned),
+			state: sim?.state ?? (simsAvailable ? "missing" : "unknown")
+		} : null,
+		android: android ? {
+			name: android.avdName ?? android.serial,
+			owned: Boolean(android.owned),
+			physical: Boolean(android.serial && !android.avdName)
+		} : null,
+		metro: project.metroPort ? {
+			port: project.metroPort,
+			running: metroRunning,
+			pid: metro?.metro?.pid ?? null
+		} : null,
+		supervisor: supervisor ? {
+			pid: supervisor.pid ?? null,
+			mode: supervisor.mode ?? null,
+			startedAt: supervisor.startedAt ?? null,
+			healthy: Boolean(supervisor.healthy)
+		} : null,
+		logs: logs ? {
+			dir: logs.dir,
+			errorsSinceMarker: logs.errorsSinceMarker ?? 0
+		} : null,
+		worktree: worktrees.find((w) => w.path === project.__path) ?? null
+	};
+}
+function capacity(states, totalMemoryMb) {
+	const committedMb = states.reduce((n, s) => n + s.memoryMb, 0);
+	return {
+		liveCount: states.filter((s) => s.live).length,
+		committedMb,
+		totalMemoryMb,
+		overCapacity: Boolean(totalMemoryMb && committedMb > totalMemoryMb * .6)
+	};
+}
+function parseDfFree(output) {
+	const lines = String(output || "").trim().split("\n");
+	if (lines.length < 2) return null;
+	const lastLine = lines[lines.length - 1];
+	if (lastLine === void 0) return null;
+	const m = /\s(\d+)\s+(\d+)\s+(\d+)\s+(\d+)%/.exec(lastLine);
+	if (!m) return null;
+	const totalKb = Number(m[1]);
+	const availableKb = Number(m[3]);
+	if (!Number.isFinite(totalKb) || !Number.isFinite(availableKb) || totalKb <= 0) return null;
+	return {
+		availableMb: Math.round(availableKb / 1024),
+		totalMb: Math.round(totalKb / 1024)
+	};
+}
+function diskIsTight(disk) {
+	return Boolean(disk && disk.availableMb < 25600);
+}
+function formatSpace(mb) {
+	if (!Number.isFinite(mb)) return "?";
+	if (mb >= 1048576) return `${(mb / 1048576).toFixed(1)} TB`;
+	if (mb >= 1024) return `${Math.round(mb / 1024)} GB`;
+	return `${Math.round(mb)} MB`;
+}
+function diskLine(volumes) {
+	const usable = (volumes || []).filter((v) => Boolean(v && v.disk));
+	if (usable.length === 0) return null;
+	if (usable.length === 1) {
+		const first = usable[0];
+		if (!first) return null;
+		const { disk } = first;
+		return `${formatSpace(disk.availableMb)} free of ${formatSpace(disk.totalMb)} on disk.`;
+	}
+	return `${usable.map((v) => `${formatSpace(v.disk.availableMb)} free on ${v.volume}`).join(", ")}.`;
+}
+function tightVolumes(volumes) {
+	return (volumes || []).filter((v) => v && diskIsTight(v.disk));
+}
+function unprovisionedWorktrees(worktrees, projectPaths) {
+	const known = new Set(projectPaths);
+	return worktrees.filter((w) => !known.has(w.path));
+}
+function deviceLeaseStates(entries, { root, now }) {
+	return entries.map((entry) => {
+		const lease = entry.lease;
+		return {
+			path: entry.path,
+			platform: entry.platform,
+			id: entry.id,
+			deviceName: lease?.deviceName ?? null,
+			holder: lease?.holder ?? null,
+			grantedAt: lease?.grantedAt ?? null,
+			expiresAt: lease?.expiresAt ?? null,
+			mine: Boolean(lease && root && lease.holder === root),
+			expired: Boolean(lease && Date.parse(lease.expiresAt) <= now),
+			parsed: Boolean(lease)
+		};
+	});
+}
+function deviceLeaseLines(states, now) {
+	if (states.length === 0) return [];
+	const lines = [`Device leases (${states.length}):`];
+	for (const state of states) {
+		const device = `${state.platform} ${state.id ?? state.path}${state.deviceName ? ` (${state.deviceName})` : ""}`;
+		if (!state.parsed || state.expiresAt === null) {
+			lines.push(`  ${device} -- unreadable lease file, so nothing may take the device: ${state.path}`);
+			continue;
+		}
+		const when = clockTime(state.expiresAt);
+		const remaining = Date.parse(state.expiresAt) - now;
+		const expiry = state.expired ? `expired at ${when}` : `until ${when} (${formatElapsed(remaining)} left)`;
+		lines.push(`  ${device} -- ${state.holder} ${expiry}${state.mine ? " [this workspace]" : ""}`);
+	}
+	return lines;
+}
+//#endregion
+//#region src/commands/status.ts
+function formatGb(mb) {
+	return `${(mb / 1024).toFixed(1)} GB`;
+}
+function statusCommand(program) {
+	program.command("status").description("Show every environment on this machine: devices, ports, what is actually running, and anything stuck.").option("--json", "print the state as JSON").action(async (opts) => {
+		const cfg = loadConfig();
+		const projects = Object.entries(cfg?.projects || {});
+		const cwdRoot = findProjectRoot(process.cwd());
+		const simsByUdid = {};
+		let simsAvailable = true;
+		let simctlError = null;
+		try {
+			for (const sim of listAllIosSims()) simsByUdid[sim.udid] = sim;
+		} catch (e) {
+			simsAvailable = false;
+			simctlError = String(e?.message || e).split("\n")[0] ?? "";
+		}
+		const worktrees = listWorktrees(process.cwd()).slice(1);
+		const states = [];
+		const labelOnlyRoots = [];
+		for (const [path, proj] of projects) {
+			let metro = null;
+			if (proj.metroPort) metro = await resolveOnPort(proj.metroPort, path);
+			const supervisor = await supervisorFacts(path, proj, metro);
+			states.push(environmentState({
+				...proj,
+				__path: path
+			}, {
+				simsByUdid,
+				metro,
+				worktrees,
+				simsAvailable,
+				supervisor,
+				logs: logFacts(path)
+			}));
+			const state = states[states.length - 1];
+			labelOnlyRoots.push(Boolean(proj.worktreeRoot && !proj.bundleId && !state?.metro && !state?.ios && !state?.android));
+		}
+		const leaseNow = Date.now();
+		const leases = deviceLeaseStates(listLeaseFiles(), {
+			root: cwdRoot,
+			now: leaseNow
+		});
+		const cap = capacity(states, Math.round(totalmem() / 1048576));
+		const orphanWorktrees = unprovisionedWorktrees(worktrees, projects.map(([p]) => p));
+		const pools = ["ios", "android"].map((platform) => {
+			const { max, error } = parkedMaxSetting(platform);
+			return {
+				error,
+				line: poolLine({
+					platform,
+					parked: readParked(platform).length,
+					max
+				})
+			};
+		});
+		if (opts.json) {
+			console.log(JSON.stringify({
+				environments: states.map((state, i) => labelOnlyRoots[i] ? {
+					...state,
+					labelOnly: true
+				} : state),
+				capacity: cap,
+				deviceLeases: leases,
+				unprovisionedWorktrees: orphanWorktrees,
+				simctlAvailable: simsAvailable
+			}));
+			return;
+		}
+		if (projects.length === 0 && orphanWorktrees.length === 0) {
+			console.log(chalk.dim("No projects registered."));
+			for (const pool of pools) {
+				if (pool.error) console.log(chalk.yellow(`${pool.error} ${POOL_SETTING_REMEDY}`));
+				if (pool.line) console.log(chalk.dim(pool.line));
+			}
+			for (const line of deviceLeaseLines(leases, leaseNow)) console.log(line);
+			return;
+		}
+		if (!simsAvailable) console.log(chalk.yellow(`simctl could not be read (${simctlError}), so no iOS sim below could be checked.`));
+		for (const [i, [path, proj]] of projects.entries()) {
+			const state = states[i];
+			if (!state) continue;
+			const shortcut = projectShortcut(path, proj);
+			const marker = path === cwdRoot ? chalk.bold.cyan(`* ${shortcut}`) : shortcut;
+			const idle = state.live ? "" : chalk.dim(" [idle]");
+			console.log(`\n${marker}${idle} ${chalk.dim(`(${path})`)}`);
+			console.log(labelOnlyRoots[i] ? chalk.dim("  worktree root (holds the label; the app registers its own entry)") : chalk.dim(`  app: ${proj.bundleId ?? "?"} (${proj.isExpo ? "expo" : "bare"})`));
+			if (state.metro) {
+				const label = state.metro.running ? chalk.green(`running (pid ${state.metro.pid})`) : chalk.dim("not running");
+				console.log(`  metro: port ${state.metro.port} ${label}`);
+			}
+			if (state.supervisor) {
+				const health = state.supervisor.healthy ? chalk.green("healthy") : chalk.yellow("not answering");
+				const mode = state.supervisor.mode ? chalk.dim(` (${state.supervisor.mode})`) : "";
+				console.log(`  supervisor: pid ${state.supervisor.pid}${mode} ${health}`);
+			}
+			if (state.logs) {
+				const n = state.logs.errorsSinceMarker;
+				const errs = n > 0 ? chalk.yellow(` (${n} error${n === 1 ? "" : "s"} since the last marker)`) : "";
+				console.log(chalk.dim(`  logs: ${state.logs.dir}`) + errs);
+			}
+			if (state.ios) {
+				const booted = state.ios.state === "Booted" ? chalk.green("booted") : chalk.dim(state.ios.state.toLowerCase());
+				const owned = state.ios.owned ? chalk.dim(" (owned)") : "";
+				console.log(`  ios: ${chalk.cyan(state.ios.name ?? state.ios.udid)} ${booted}${owned}`);
+			}
+			if (state.android) {
+				const kind = state.android.physical ? chalk.dim("(physical)") : chalk.dim("(emulator)");
+				console.log(`  android: ${chalk.cyan(state.android.name)} ${kind}${state.android.owned ? chalk.dim(" (owned)") : ""}`);
+			}
+			for (const w of state.warnings) console.log(chalk.yellow(`  ! ${w}`));
+		}
+		for (const pool of pools) {
+			if (pool.error) console.log(chalk.yellow(`\n${pool.error} ${POOL_SETTING_REMEDY}`));
+			if (pool.line) console.log(chalk.dim(`\n${pool.line}`));
+		}
+		const leaseLines = deviceLeaseLines(leases, leaseNow);
+		if (leaseLines.length) {
+			console.log("");
+			for (const line of leaseLines) console.log(line);
+		}
+		if (orphanWorktrees.length) {
+			console.log(chalk.dim(`\nWorktrees with no environment (${orphanWorktrees.length}):`));
+			for (const w of orphanWorktrees) console.log(chalk.dim(`  ${w.path}${w.branch ? ` [${w.branch}]` : ""}`));
+		}
+		console.log(chalk.dim(`\n${cap.liveCount} live environment(s), roughly ${formatGb(cap.committedMb)} of ${formatGb(cap.totalMemoryMb)} committed.`));
+		const volumes = readVolumes(cwdRoot || process.cwd());
+		const line = diskLine(volumes);
+		if (line) {
+			const tight = tightVolumes(volumes);
+			if (tight.length) {
+				const which = tight.map((v) => v.volume).join(" and ");
+				console.log(chalk.yellow(`${line} A single iOS build can exhaust ${which} -- run \`stim gc\` before starting another environment.`));
+			} else console.log(chalk.dim(line));
+		}
+		if (cap.overCapacity) console.log(chalk.yellow("Over comfortable capacity. A machine that swaps is slower than one working in sequence -- release one before starting another."));
+	});
+}
+function readVolumes(projectPath) {
+	const roots = [.../* @__PURE__ */ new Set([
+		"/",
+		volumeRootFor(getConfigDir()),
+		volumeRootFor(projectPath)
+	])];
+	const volumes = [];
+	for (const volume of roots) {
+		const quoted = `'${volume.replace(/'/g, "'\\''")}'`;
+		const disk = parseDfFree(getExecutor().runQuiet(`df -k ${quoted}`, { timeoutMs: 5e3 }));
+		if (disk) volumes.push({
+			volume,
+			disk
+		});
+	}
+	return volumes;
+}
+async function resolveOnPort(port, path) {
+	return await isMetroRunning(port) ? resolveProjectMetro(port, path) : { missing: true };
+}
+async function supervisorFacts(path, proj, metroResolution) {
+	const state = readSupervisorState(path);
+	const record = proj?.supervisor ?? null;
+	const pid = state?.pid ?? record?.pid ?? null;
+	if (!pid) return null;
+	const port = state?.port ?? record?.port ?? null;
+	const alive = resolveSupervisorTarget({
+		state,
+		record,
+		reservedPort: proj?.metroPort
+	}).status === "ours";
+	let healthy = false;
+	if (alive && port) {
+		const resolution = port === proj?.metroPort && metroResolution ? metroResolution : await resolveOnPort(port, path);
+		healthy = Boolean(resolution?.metro);
+	}
+	return {
+		pid,
+		mode: state?.mode ?? record?.mode ?? null,
+		startedAt: state?.startedAt ?? record?.startedAt ?? null,
+		alive,
+		healthy
+	};
+}
+function logFacts(path) {
+	const dir = workspaceLogsDir(path);
+	if (!existsSync(dir)) return null;
+	try {
+		return {
+			dir,
+			errorsSinceMarker: queryLogs({
+				dir,
+				errorsOnly: true
+			}).length
+		};
+	} catch {
+		return {
+			dir,
+			errorsSinceMarker: 0
+		};
+	}
+}
+//#endregion
+export { statusCommand as default, readVolumes };