stim 1.20.2 → 1.21.0

package/dist/status-CSi6tlRq.mjs

@@ -0,0 +1,2 @@
+import { n as runStatusWatch, r as statusCommand, t as readVolumes } from "./status-BL7jVyAB.mjs";
+export { statusCommand as default, readVolumes, runStatusWatch };

package/dist/{status-BTA7kKiQ.mjs → status-DqEUSSxs.mjs}

@@ -1,14 +1,14 @@
-import { N as formatBytes } from "./config-BYDxlMY3.mjs";
+import { P as formatBytes } from "./config-CYcBF478.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
 import { maintenanceRunClaims, readMaintenanceState } from "@stim-cli/core/state";
 import { claimRemoveCommand, readClaimSet } from "@stim-cli/core/ownership-claim";
 //#region src/maintenance/status.ts
-function maintenanceStatus() {
+function maintenanceStatus(env = process.env) {
 	const state = readMaintenanceState();
 	const claims = readClaimSet(maintenanceRunClaims());
 	const holder = claims.live[0];
 	const unresolved = claims.unresolved[0];
-	const settings = resolveMaintenanceSettings();
+	const settings = resolveMaintenanceSettings(void 0, env);
 	return {
 		mode: settings.mode,
 		...settings.invalid ? { invalid: settings.invalid } : {},
@@ -42,8 +42,10 @@ function maintenanceLine(status, includeLabel = true) {
 	const outputs = status.plan.filter((action) => action.kind === "would-clear-outputs");
 	const summary = status.mode === "on" && status.lastPass ? `${status.lastPass.actions} actions, ${(status.lastPass.freedBytes / 1024 ** 3).toFixed(1)} GB freed` : outputs.length ? `would clear build outputs of ${outputs.length} ${outputs.length === 1 ? "workspace" : "workspaces"} (${(outputs.reduce((sum, action) => sum + action.bytes, 0) / 1024 ** 3).toFixed(1)} GB)` : `${status.plan.length} planned actions`;
 	const disk = status.pressure?.disk.map((volume) => `disk ${(volume.freeMb / 1024).toFixed(1)} GB free on ${volume.volume}`).join(", ");
+	const devices = status.sizes.filter((size) => size.category === "owned-devices");
+	const deviceDisk = devices.length ? `owned devices ${formatBytes(devices.reduce((sum, size) => sum + size.bytes, 0))}` : null;
 	const culprits = (status.mode === "off" ? void 0 : status.pressure?.memory.culprits)?.map((culprit) => `${culprit.name} uses ${formatBytes(culprit.bytes)}${culprit.command ? ` (\`${culprit.command}\`)` : ""}`).join(", ");
-	return `${includeLabel ? `Auto maintenance (${status.mode === "report" ? "report only" : status.mode}): ` : ""}${at ? `${at}: ` : ""}${status.lastPass ? summary : "no pass has run yet"}${disk ? `; ${disk}` : ""}${culprits ? `; memory: ${culprits}` : ""}${status.running ? "; running" : ""}${status.lastPass?.blocked.length ? `; ${status.lastPass.blocked.join("; ")}` : ""}${status.invalid ? `; invalid: ${status.invalid}` : ""}${status.claim ? `; unresolved claim: ${status.claim.unresolved}; ${status.claim.removeCommand}` : ""}`;
+	return `${includeLabel ? `Auto maintenance (${status.mode === "report" ? "report only" : status.mode}): ` : ""}${at ? `${at}: ` : ""}${status.lastPass ? summary : "no pass has run yet"}${disk ? `; ${disk}` : ""}${deviceDisk ? `; ${deviceDisk}` : ""}${status.pressure?.diskLevel ? `; disk pressure level ${status.pressure.diskLevel}` : ""}${culprits ? `; memory: ${culprits}` : ""}${status.running ? "; running" : ""}${status.lastPass?.blocked.length ? `; ${status.lastPass.blocked.join("; ")}` : ""}${status.invalid ? `; invalid: ${status.invalid}` : ""}${status.claim ? `; unresolved claim: ${status.claim.unresolved}; ${status.claim.removeCommand}` : ""}`;
 }
 function maintenanceLines(status) {
 	const line = maintenanceLine(status);

package/dist/{status-watch-C23ILtf9.mjs → status-watch-GDCfqpTE.mjs}

@@ -1,13 +1,17 @@
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { d as androidToolPath } from "./android-Mz_Inn3w.mjs";
-import { b as parseSimctlList } from "./ios-RkW4pnQf.mjs";
-import { n as easMachineStateRoot } from "./eas-session-ledger-Cm0Gwq2F.mjs";
-import { readdirSync, watch } from "node:fs";
-import { join } from "node:path";
+import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { l as pidExists } from "./metro-DEXpIhHC.mjs";
+import { n as easMachineStateRoot } from "./eas-session-ledger-op6A54yi.mjs";
+import { d as androidToolPath } from "./android-DUYkNF4u.mjs";
+import { b as parseSimctlList } from "./ios-CpByZy12.mjs";
+import { readdirSync, statSync, watch } from "node:fs";
+import { dirname, join } from "node:path";
 //#region src/status-watch.ts
 const WATCH_FALLBACK_MS = 3e4;
-const WATCH_LIGHT_INTERVAL_MS = 15e3;
-const WATCH_SIMCTL_INTERVAL_MS = 5e3;
+const WATCH_LIGHT_INTERVAL_MS = 1e3;
+const WATCH_TABLES_INTERVAL_MS = 5e3;
+const WATCH_MACHINE_INTERVAL_MS = 15e3;
+const WATCH_PROCESS_INTERVAL_MS = 2e3;
+const WATCH_SIMCTL_INTERVAL_MS = 3e4;
 const ADB_RESTART_MIN_MS = 1e3;
 const ADB_RESTART_MAX_MS = 6e4;
 const SIMCTL_TIMEOUT_MS = 1e4;
@@ -86,6 +90,16 @@ function statusChange(dir, name) {
 		default: return "full";
 	}
 }
+/**
+* Whether a change to `name`, relative to a repository's git common directory, can change a worktree's git summary:
+* its HEAD, index or a ref, in the main worktree or a linked one. Objects, logs and lock files cannot on their own.
+*/
+function gitChange(name) {
+	if (name === null) return true;
+	const path = name.replaceAll("\\", "/");
+	if (path.endsWith(".lock")) return false;
+	return /^(HEAD|index|packed-refs|FETCH_HEAD)$/.test(path) || path.startsWith("refs/") || /^worktrees\/[^/]+(\/(HEAD|index))?$/.test(path) || path === "worktrees";
+}
 /** A stable summary of every simulator's state, or null when the listing is unreadable. */
 function simulatorSignature(simctlJson) {
 	try {
@@ -94,12 +108,18 @@ function simulatorSignature(simctlJson) {
 		return null;
 	}
 }
+const SIMULATOR_DIR = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
 /**
 * Calls `onChange` when anything `stim status` reports may have changed:
-* `$STIM_HOME` files, adb device arrivals and departures, and simulator
-* state. simctl has no push API reachable from Node, so it is polled.
+* `$STIM_HOME` files, git HEADs, indexes and refs of the watched repositories,
+* exits of the watched processes, adb device arrivals and departures, and
+* simulator state. Process liveness is polled with a signal 0 that spawns
+* nothing. simctl has no push API reachable from Node, so a simulator change is
+* a write CoreSimulator makes in `deviceSet`: to `device_set.plist`, a device
+* directory, or a device's `device.plist`, which carries its state. A slow
+* simctl poll covers events FSEvents drops and a device set that cannot be watched.
 */
-function watchStatusSources({ home, onChange, platform = process.platform, simctlIntervalMs = WATCH_SIMCTL_INTERVAL_MS }) {
+function watchStatusSources({ home, deviceSet, onChange, platform = process.platform, simctlIntervalMs = WATCH_SIMCTL_INTERVAL_MS }) {
 	let stopped = false;
 	const watchers = /* @__PURE__ */ new Map();
 	const desiredDirs = () => {
@@ -136,7 +156,7 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 					const change = statusChange(kind, name === null ? null : String(name));
 					if (!change) return;
 					if (kind === "home" || kind === "workspaces" || kind === "workspace") {
-						listingStaleBefore = Date.now();
+						listingVersion++;
 						reconcile();
 					}
 					onChange(change);
@@ -149,16 +169,98 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			} catch {}
 		}
 	};
+	const repositories = /* @__PURE__ */ new Map();
+	const watchRepositories = (commonDirs) => {
+		if (stopped) return;
+		const wanted = new Set(commonDirs);
+		for (const [dir, watcher] of repositories) {
+			if (wanted.has(dir)) continue;
+			watcher.close();
+			repositories.delete(dir);
+		}
+		for (const dir of wanted) {
+			if (repositories.has(dir)) continue;
+			try {
+				const watcher = watch(dir, { recursive: true }, (_event, name) => {
+					if (gitChange(name === null ? null : String(name))) onChange("full");
+				});
+				watcher.on("error", () => {
+					watcher.close();
+					repositories.delete(dir);
+				});
+				repositories.set(dir, watcher);
+			} catch {}
+		}
+	};
+	let processes = [];
+	const processTimer = setInterval(() => {
+		if (processes.some((pid) => !pidExists(pid))) {
+			processes = [];
+			onChange("full");
+		}
+	}, WATCH_PROCESS_INTERVAL_MS);
+	processTimer.unref();
 	const adb = trackAdbDevices(() => onChange("full"));
 	let simctl = null;
 	let listing = null;
-	let listingStaleBefore = 0;
+	let listingVersion = 0;
 	let simTimer = null;
-	if (platform === "darwin") {
+	const deviceWatchers = /* @__PURE__ */ new Map();
+	if (platform === "darwin" && deviceSet) {
+		const changed = () => {
+			listingVersion++;
+			check();
+			onChange("full");
+		};
+		const watchDir = (dir, listener) => {
+			if (deviceWatchers.has(dir)) return;
+			try {
+				const watcher = watch(dir, (_event, name) => listener(name === null ? null : String(name)));
+				watcher.on("error", () => {
+					watcher.close();
+					deviceWatchers.delete(dir);
+				});
+				deviceWatchers.set(dir, watcher);
+			} catch {}
+		};
+		const watchDeviceSet = () => {
+			if (stopped) return;
+			let names = null;
+			try {
+				names = readdirSync(deviceSet);
+			} catch {}
+			const wanted = /* @__PURE__ */ new Set();
+			if (names) {
+				wanted.add(deviceSet);
+				for (const name of names) if (SIMULATOR_DIR.test(name)) wanted.add(join(deviceSet, name));
+			} else {
+				let dir = dirname(deviceSet);
+				while (dirname(dir) !== dir && !isDirectory(dir)) dir = dirname(dir);
+				wanted.add(dir);
+			}
+			for (const [dir, watcher] of deviceWatchers) {
+				if (wanted.has(dir)) continue;
+				watcher.close();
+				deviceWatchers.delete(dir);
+			}
+			for (const dir of wanted) if (dir === deviceSet) watchDir(dir, () => {
+				watchDeviceSet();
+				changed();
+			});
+			else if (dirname(dir) === deviceSet) watchDir(dir, (name) => {
+				if (name === null || name === "device.plist") changed();
+			});
+			else watchDir(dir, () => {
+				watchDeviceSet();
+				if (deviceWatchers.has(deviceSet)) changed();
+			});
+		};
 		let last = null;
 		const check = () => {
+			watchDeviceSet();
 			if (simctl || stopped) return;
 			const startedAt = Date.now();
+			const version = listingVersion;
 			let out = "";
 			const child = getExecutor().spawn("xcrun", [
 				"simctl",
@@ -176,18 +278,23 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 			});
 			simctl = child;
 			child.stdout?.on("data", (chunk) => out += chunk.toString());
-			child.on("error", () => {
-				simctl = null;
-			});
+			child.on("error", () => {});
 			child.on("close", () => {
 				simctl = null;
+				if (stopped) return;
+				if (version !== listingVersion) {
+					check();
+					return;
+				}
 				const signature = simulatorSignature(out);
-				if (signature === null || stopped) return;
+				if (signature === null) return;
+				const wasStale = listing?.version !== version;
 				listing = {
 					at: startedAt,
+					version,
 					json: out
 				};
-				if (last !== null && signature !== last) onChange("full");
+				if (last !== null && (signature !== last || wasStale)) onChange("full");
 				last = signature;
 			});
 		};
@@ -197,12 +304,21 @@ function watchStatusSources({ home, onChange, platform = process.platform, simct
 	reconcile();
 	return {
 		reconcile,
-		simulatorListing: () => listing && listing.at > listingStaleBefore && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
+		watchRepositories,
+		watchProcesses(pids) {
+			processes = [...new Set(pids)];
+		},
+		simulatorListing: () => listing && listing.version === listingVersion && Date.now() - listing.at <= 2 * simctlIntervalMs ? listing.json : null,
 		stop() {
 			stopped = true;
 			for (const watcher of watchers.values()) watcher.close();
 			watchers.clear();
+			for (const watcher of repositories.values()) watcher.close();
+			repositories.clear();
+			clearInterval(processTimer);
 			if (simTimer) clearInterval(simTimer);
+			for (const watcher of deviceWatchers.values()) watcher.close();
+			deviceWatchers.clear();
 			simctl?.kill("SIGKILL");
 			adb.stop();
 		}
@@ -249,6 +365,13 @@ function trackAdbDevices(onChange) {
 		child?.kill("SIGTERM");
 	} };
 }
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
 function ownerKey(owner) {
 	return JSON.stringify([
 		owner.kind,
@@ -265,7 +388,7 @@ function ownerSteady(before, after) {
 /**
 * The payload `status --watch --json` prints. A usage figure keeps its value from the `previous` printed payload until it moves by a step: an owner's `cpuPercent`
 * and `memoryMb`, an environment's `memoryMb` and `capacity.committedMb`. An owner's row is kept whole, `residentMb`
-* and `processes` included, until one of its two figures moves, so a Mac whose processes only jitter prints no new line.
+* and `processes` included, until one of its two figures moves, so a machine whose processes only jitter prints no new line.
 */
 function watchPayload(previous, next) {
 	const payload = { ...next };
@@ -292,5 +415,47 @@ function watchPayload(previous, next) {
 	if (capacity.overCapacity === next.capacity.overCapacity && capacity.liveCount === next.capacity.liveCount && capacity.totalMemoryMb === next.capacity.totalMemoryMb && Math.abs(next.capacity.committedMb - capacity.committedMb) < 16) payload.capacity = capacity;
 	return payload;
 }
+const holdPullRequest = (worktree) => worktree.pullRequest ? {
+	...worktree,
+	pullRequest: {
+		...worktree.pullRequest,
+		checkedAt: ""
+	}
+} : worktree;
+/**
+* The string `status --watch --json` compares to decide whether a line is new. It is the payload with the bookkeeping
+* timestamps masked: each `pullRequest.checkedAt`, `maintenance.lastChecks`, `maintenance.lastPass.startedAt` and
+* `durationMs`, and `maintenance.running.startedAt`. A change in only those fields prints no line; any printed line
+* carries the current values.
+*/
+function watchChangeKey(payload) {
+	const { maintenance } = payload;
+	return JSON.stringify({
+		...payload,
+		environments: payload.environments.map((env) => env.worktree ? {
+			...env,
+			worktree: holdPullRequest(env.worktree)
+		} : env),
+		unprovisionedWorktrees: payload.unprovisionedWorktrees.map(holdPullRequest),
+		maintenance: maintenance && {
+			...maintenance,
+			lastChecks: {
+				pressure: null,
+				size: null,
+				worktree: null,
+				sweep: null
+			},
+			lastPass: maintenance.lastPass && {
+				...maintenance.lastPass,
+				startedAt: 0,
+				durationMs: 0
+			},
+			running: maintenance.running && {
+				...maintenance.running,
+				startedAt: ""
+			}
+		}
+	});
+}
 //#endregion
-export { watchStatusSources as a, watchPayload as i, WATCH_LIGHT_INTERVAL_MS as n, createRefreshScheduler as r, WATCH_FALLBACK_MS as t };
+export { createRefreshScheduler as a, watchStatusSources as c, WATCH_TABLES_INTERVAL_MS as i, WATCH_LIGHT_INTERVAL_MS as n, watchChangeKey as o, WATCH_MACHINE_INTERVAL_MS as r, watchPayload as s, WATCH_FALLBACK_MS as t };

package/dist/status-worker.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/status-worker.mjs

@@ -0,0 +1,19 @@
+import { n as runStatusWatch } from "./status-BL7jVyAB.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+//#region src/status-worker.ts
+const STOP_EXIT_MS = 500;
+const cwd = workerData?.cwd;
+const watch = runStatusWatch({
+	json: true,
+	...typeof cwd === "string" ? { cwd } : {},
+	emit: (line) => parentPort?.postMessage({ line }),
+	failed: (message) => parentPort?.postMessage({ failed: message })
+});
+parentPort?.on("message", (message) => {
+	if (message !== "stop") return;
+	watch.stop();
+	parentPort?.close();
+	setTimeout(() => process.exit(0), STOP_EXIT_MS);
+});
+//#endregion
+export {};

package/dist/stim-desktop-C12we7lz.mjs

@@ -0,0 +1,112 @@
+import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { C as saveConfig, c as ensureConfig } from "./config-CYcBF478.mjs";
+import { randomUUID } from "node:crypto";
+import { workspaceId } from "@stim-cli/core";
+import { readHomeIdentity, withConfigLockAsync } from "@stim-cli/core/state";
+import { realpath } from "node:fs/promises";
+import { sharedWorkspaceURL } from "@stim-cli/core/workspace-link";
+//#region src/workspace/home-identity.ts
+function ensureHomeIdentity(signal) {
+	return withConfigLockAsync(() => {
+		signal?.throwIfAborted();
+		const config = ensureConfig();
+		const existing = readHomeIdentity(config);
+		if (existing) return existing;
+		const id = randomUUID();
+		config.homeId = id;
+		saveConfig(config);
+		return id;
+	});
+}
+//#endregion
+//#region src/devices/stim-desktop.ts
+const LAUNCH_SERVICES_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier('dev.stim.desktop'); url.isNil() ? '' : url.path.js`;
+const SCHEME_HANDLER_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationToOpenURL($.NSURL.URLWithString('stim-desktop://workspace')); url.isNil() ? '' : url.path.js`;
+const STIM_DESKTOP_INSTALLED = "Stim Desktop installed";
+/**
+* macOS `open` passes its environment to an app it launches, so Stim Desktop
+* started by a command run under a scoped `STIM_HOME` would serve that home.
+*/
+const STIM_DESKTOP_OPEN_OPTIONS = {
+	timeoutMs: 5e3,
+	killSignal: "SIGKILL",
+	omitEnv: ["STIM_HOME"]
+};
+/** Stim Desktop sets `STIM_DESKTOP_APP` to its bundle path for every command it runs; a non-empty value means Desktop is installed. */
+function stimDesktopInstalled(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return launchServicesFinds(LAUNCH_SERVICES_LOOKUP);
+}
+/** `stimDesktopInstalled` without blocking the event loop. */
+async function stimDesktopInstalledAsync(platform = process.platform, env = process.env, onSpawn) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	const found = await getExecutor().runFileAsync("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		LAUNCH_SERVICES_LOOKUP
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL",
+		onSpawn
+	}).catch(() => "");
+	return Boolean(found);
+}
+function launchServicesFinds(script) {
+	return Boolean(getExecutor().runFileQuiet("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		script
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}));
+}
+async function stimDesktopHandlesLinks(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return Boolean(await getExecutor().runFileAsync("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		SCHEME_HANDLER_LOOKUP
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}).catch(() => ""));
+}
+/**
+* The links that open this workspace for a human, or undefined when no app on this Mac handles
+* `stim-desktop://`. `target` names the device Stim Desktop focuses when the user opens the workspace.
+*/
+async function workspaceLinks(root, target, handlesLinks = stimDesktopHandlesLinks) {
+	if (!await handlesLinks()) return void 0;
+	return { desktop: await workspaceShareURL(root, target) };
+}
+/** A share URL for the canonical workspace in this Stim home, usable by its already-paired phone or Desktop. */
+async function workspaceShareURL(root, target, signal) {
+	const canonical = await realpath(root);
+	return sharedWorkspaceURL({
+		machine: await ensureHomeIdentity(signal),
+		workspace: workspaceId(canonical),
+		...target
+	});
+}
+function workspaceLinkLine(links) {
+	return `Open in Stim: ${links.desktop}`;
+}
+function settingDefault(setting, desktopInstalled = stimDesktopInstalled) {
+	if (setting.desktopDefault !== void 0 && desktopInstalled()) return {
+		value: setting.desktopDefault,
+		reason: STIM_DESKTOP_INSTALLED
+	};
+	return {
+		value: setting.default,
+		reason: null
+	};
+}
+//#endregion
+export { workspaceLinkLine as a, ensureHomeIdentity as c, stimDesktopInstalledAsync as i, settingDefault as n, workspaceLinks as o, stimDesktopInstalled as r, workspaceShareURL as s, STIM_DESKTOP_OPEN_OPTIONS as t };

package/dist/{stop-DR6VoDIk.mjs → stop-Bk_1qiV6.mjs}

@@ -1,3 +1,3 @@
-import { P as resolveSupervisorTarget } from "./workspaces-C36s2jb9.mjs";
-import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BNmBMi1F.mjs";
+import { m as resolveSupervisorTarget } from "./workspaces-BccMFmGQ.mjs";
+import { a as resolveCollectorTargets, c as stopWorkspaceNow, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-CPzlM1L-.mjs";
 export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop, stopWorkspaceNow };