stim 1.14.0 → 1.16.0

package/dist/{start-s4RXp1wy.mjs → start-ClDfwXa4.mjs}

@@ -1,24 +1,26 @@
-import { O as process_identity_exports, T as upsertProject, p as getProject } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { i as levelRank } from "./ndjson-CDY9IkVC.mjs";
-import { E as supervisorLogFile, M as workspaceLogsDir, S as ensureWorkspaceStorage, a as pidExists, b as writeWorkspaceState, c as resolveProjectMetro, f as reserveMetroPort, g as recordWorkspaceUse, h as readWorkspaceState$1, l as signalProcessTree, m as clearWorkspaceStateKeys } from "./metro-CcEo8Fl8.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-BVrHsYZG.mjs";
-import { a as findProjectRoot, d as readAppJson, n as appProjectProblem, r as detectIsExpo, t as NO_PROJECT_REFUSAL, u as readAppConfigText } from "./project-CWlvEaeN.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-DJHoca49.mjs";
-import { c as readMetroTunnel, i as clearManagedMetroTunnel } from "./state-DHqvsbqC.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError } from "./named-ports-Blg8IxOh.mjs";
-import { _ as stepTimer, l as phaseLine } from "./command-output-DVcpw6eE.mjs";
-import { A as resolveCacheProviderConfig, B as detectProviders, C as ngrokUrlSetting, E as publicUrlSetting, I as tunnelModeSetting, L as unknownSettingKeys, O as remoteAndroidSetting, P as settingShapeErrors, V as planMetroReach, a as SETTING_SHAPE_REMEDY, b as metroIdleStopMinutesSetting, d as cacheProviderSettingError, j as resolveSettings, k as remoteIosSetting, x as metroTunnelSettingError, z as PUBLIC_METRO_ENV } from "./settings-D61iNOsB.mjs";
-import { _ as withManagedTunnelLock, f as startTunnelSequence, h as withManagedRemoteWorktreeLock, m as terminateChild, p as stopTunnel, u as resolveSupervisorTarget } from "./stop-cause-hjGBOZTG.mjs";
-import { d as readProjectConfig } from "./remote-cache-CcR6o6lI.mjs";
-import { I as stopOwnedMetroForReset, t as budgetGate } from "./budget-CGDkhvv_.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { E as upsertProject, p as getProject } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
+import { _ as stepTimer, l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { C as metroTunnelSettingError, G as detectProviders, H as unknownSettingKeys, K as planMetroReach, M as remoteIosSetting, N as resolveCacheProviderConfig, P as resolveSettings, R as settingShapeErrors, S as metroPortSetting, T as ngrokUrlSetting, V as tunnelModeSetting, W as PUBLIC_METRO_ENV, a as SETTING_SHAPE_REMEDY, d as cacheProviderSettingError, f as deviceIdleShutdownMinutesSetting, gt as repoRoot, it as gitCommonDir, j as remoteAndroidSetting, k as publicUrlSetting, x as metroIdleStopMinutesSetting } from "./settings-oTSkkNrM.mjs";
+import { d as readAppConfigText, f as readAppJson, n as appProjectProblem, o as findProjectRoot$1, r as detectIsExpo, t as NO_PROJECT_REFUSAL } from "./project-Du91Ilvc.mjs";
+import { l as resolveProjectMetro, o as pidExists, p as reserveMetroPort, u as signalProcessTree } from "./metro-BeK1ZPz1.mjs";
+import { c as writeWorkspaceState, g as workspaceAgentDeviceDir, i as recordWorkspaceUse, m as supervisorLogFile, n as clearWorkspaceStateKeys, r as readWorkspaceState$1, u as ensureWorkspaceStorage, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { c as stopOwnedMetroForReset, t as budgetGate } from "./budget-DjrURfQn.mjs";
+import { c as readMetroTunnel, i as clearManagedMetroTunnel } from "./state-DcW6vOd_.mjs";
+import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-Cnz8CPnl.mjs";
+import { n as workspaceProcessLockError, t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { a as terminateChild, c as withManagedTunnelLock, i as stopTunnel, o as withManagedRemoteWorktreeLock, r as startTunnelSequence, t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { i as levelRank } from "./ndjson-PclOIwVY.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { d as readProjectConfig } from "./remote-cache-C8-V13XN.mjs";
 import { appendFileSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { EventEmitter } from "node:events";
 import { existsSync as existsSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1 } from "fs";
-import { join } from "path";
+import { join as join$1 } from "path";
 import { IDLE_STOP_KEY, queryLogs } from "@stim-cli/core/state";
-import { basename as basename$1, dirname as dirname$1, join as join$1 } from "node:path";
-import { EventEmitter } from "node:events";
-import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { CACHE_PROVIDER_ENV, cacheProviderEnv } from "@stim-cli/cache";
 //#region src/workspace/app-id.ts
@@ -60,7 +62,7 @@ function detectAndroidPackage(projectRoot) {
 	return detectAppIds(projectRoot).androidPackage;
 }
 function detectBundleIdFromPbxproj(projectRoot) {
-	const iosDir = join(projectRoot, "ios");
+	const iosDir = join$1(projectRoot, "ios");
 	if (!existsSync$1(iosDir)) return null;
 	let entries;
 	try {
@@ -70,7 +72,7 @@ function detectBundleIdFromPbxproj(projectRoot) {
 	}
 	for (const entry of entries) {
 		if (!entry.isDirectory() || !entry.name.endsWith(".xcodeproj")) continue;
-		const pbx = join(iosDir, entry.name, "project.pbxproj");
+		const pbx = join$1(iosDir, entry.name, "project.pbxproj");
 		if (!existsSync$1(pbx)) continue;
 		let text;
 		try {
@@ -93,7 +95,7 @@ function detectBundleIdFromPbxproj(projectRoot) {
 	return null;
 }
 function detectAndroidPackageFromGradle(projectRoot) {
-	const gradle = join(projectRoot, "android", "app", "build.gradle");
+	const gradle = join$1(projectRoot, "android", "app", "build.gradle");
 	if (!existsSync$1(gradle)) return null;
 	let text;
 	try {
@@ -108,18 +110,6 @@ function detectAndroidPackageFromGradle(projectRoot) {
 	return null;
 }
 //#endregion
-//#region src/spawn-entry.ts
-const DEV_ENTRIES = {
-	"supervisor-run": "./supervisor/run.ts",
-	"collector-run": "./collector/run.ts",
-	"web-run": "./web/run.ts"
-};
-function spawnEntry(name) {
-	const here = fileURLToPath(import.meta.url);
-	if (basename$1(dirname$1(here)) === "src") return fileURLToPath(new URL(DEV_ENTRIES[name], import.meta.url));
-	return join$1(dirname$1(here), `${name}.mjs`);
-}
-//#endregion
 //#region src/commands/start.ts
 const DEFAULT_WAIT_SECONDS = 60;
 const POLL_MS = 500;
@@ -154,12 +144,13 @@ function liveSupervisor({ state, project, port, isAlive = pidExists, inspectIden
 		startedAt: target.startedAt ?? null
 	} : null;
 }
-function startFacts({ port, supervisor, logsDir, alreadyRunning }) {
+function startFacts({ root, port, supervisor, logsDir, alreadyRunning }) {
 	return {
 		port,
 		supervisorPid: supervisor?.pid ?? null,
 		mode: supervisor?.mode ?? null,
 		logsDir,
+		...root ? { agentDevice: { stateDir: workspaceAgentDeviceDir(root) } } : {},
 		alreadyRunning: Boolean(alreadyRunning)
 	};
 }
@@ -194,14 +185,14 @@ function recordedSupervisorProcess(pid) {
 	});
 }
 const RECORDED_SUPERVISOR_WAIT_MS = 15e3;
-function providersOnPath() {
+function providersOnPath(mode) {
 	return detectProviders((bin) => {
 		try {
 			return Boolean(getExecutor().findExecutable(bin));
 		} catch {
 			return false;
 		}
-	});
+	}, mode);
 }
 const DEFAULT_START_DEPS = {
 	providers: providersOnPath,
@@ -260,7 +251,7 @@ function registerStart(program, overrides = {}) {
 			remedy: "Pass a whole number of seconds, e.g. --wait 90."
 		});
 		const waitSeconds = wait.seconds;
-		const root = findProjectRoot(process.cwd());
+		const root = findProjectRoot$1(process.cwd());
 		if (!root) return fail(NO_PROJECT_REFUSAL);
 		const projectProblem = appProjectProblem(root);
 		if (projectProblem) return fail({
@@ -313,7 +304,8 @@ function registerStart(program, overrides = {}) {
 			out,
 			facts: result.facts,
 			waited: result.waited,
-			reclaimed: result.reclaimed
+			reclaimed: result.reclaimed,
+			links: workspaceLinks(root)
 		});
 	});
 }
@@ -348,7 +340,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			message: settingError,
 			remedy: "Set metro.tunnel to \"ngrok\" and metro.ngrokUrl to an HTTPS URL, or remove metro.ngrokUrl."
 		});
-		const remote = remoteFlag || remoteIosSetting(settings) !== null || remoteAndroidSetting(settings) !== null;
+		const remote = remoteFlag || remoteIosSetting(settings)?.kind === "backend" || remoteAndroidSetting(settings) !== null;
 		const tunnelMode = tunnelModeSetting(settings) ?? "auto";
 		const publicUrl = publicUrlSetting(settings);
 		const tunnel = wantsExpoOwnTunnel({
@@ -376,6 +368,11 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 			};
 			if (resetCache) {
 				await gateBudget();
+				const pin = metroPortSetting(root);
+				if (pin.port !== null || pin.error) {
+					const pinCheck = await resolveWorkspaceMetroPort(root, note, "start", false);
+					if (typeof pinCheck !== "number") return fail(pinCheck);
+				}
 				try {
 					await stopOwnedMetroForReset(root);
 				} catch (error) {
@@ -388,9 +385,9 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				}
 				note(phaseLine("cache", "clearing this app's Metro transform and file-map caches; devices preserved"));
 			}
-			const logsDir = workspaceLogsDir(root);
+			const logsDir = workspaceLogsDir$1(root);
 			const logFile = supervisorLogFile(root);
-			const port = await resolvePort(root, note);
+			const port = await resolvePort(root, note, fail);
 			let publicOrigin = remote ? publicUrl : null;
 			let resolution = await resolveProjectMetro(port, root);
 			let supervisor = liveSupervisor({
@@ -510,7 +507,9 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					...tunnel ? ["--tunnel"] : [],
 					...resetCache ? ["--reset-cache"] : [],
 					"--idle-stop-minutes",
-					String(metroIdleStopMinutesSetting(settings))
+					String(metroIdleStopMinutesSetting(settings)),
+					"--device-idle-minutes",
+					String(deviceIdleShutdownMinutesSetting(settings))
 				];
 				const childEnv = {
 					...process.env,
@@ -540,7 +539,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				return null;
 			};
 			if (remote && !tunnel && !publicUrl && tunnelMode !== "off") {
-				const available = d.providers();
+				const available = d.providers(tunnelMode);
 				const plan = planMetroReach({
 					mode: tunnelMode,
 					metroPort: port,
@@ -554,7 +553,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					remedy: plan.remedy
 				});
 				if ("start" in plan) {
-					const candidates = tunnelMode === "auto" ? available : [plan.start];
+					const candidates = tunnelMode === "auto" ? available.filter((provider) => provider !== "tailscale") : [plan.start];
 					const expectedStableUrl = ngrokUrlSetting(settings);
 					let acquisition;
 					try {
@@ -722,6 +721,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 					if ("failed" in acquisition) return fail(acquisition.failed);
 					publicOrigin = acquisition.origin;
 					managedTunnel = acquisition.tunnel;
+					if (managedTunnel.record.provider === "tailscale") note(phaseLine("lan", `tailnet-only Metro: ${publicOrigin}`));
 					resolution = await resolveProjectMetro(port, root);
 					supervisor = liveSupervisor({
 						state: readWorkspaceState$1(root),
@@ -786,6 +786,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				if (managedTunnelExited()) return failExitedManagedTunnel();
 				clearWorkspaceStateKeys(root, [IDLE_STOP_KEY]);
 				return startFacts({
+					root,
 					port,
 					supervisor,
 					logsDir,
@@ -838,6 +839,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				requireExpoTunnel();
 				if (managedTunnelExited()) return failExitedManagedTunnel();
 				return startFacts({
+					root,
 					port,
 					supervisor,
 					logsDir,
@@ -903,6 +905,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 				startedAt: null
 			};
 			return startFacts({
+				root,
 				port,
 				supervisor,
 				logsDir,
@@ -911,7 +914,7 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		};
 		const startLocked = async () => {
 			try {
-				return await withWorkspaceProcessLock(dirname$1(workspaceLogsDir(root)), "metro-start", runStart, { external: true });
+				return await withWorkspaceProcessLock(dirname(workspaceLogsDir$1(root)), "metro-start", runStart, { external: true });
 			} catch (error) {
 				if (workspaceProcessLockError(error) !== "timeout") throw error;
 				return fail({
@@ -956,24 +959,69 @@ async function startDevServer({ root, settings, waitSeconds = DEFAULT_WAIT_SECON
 		};
 	}
 }
-async function resolvePort(root, note) {
+async function resolvePort(root, note, fail) {
+	const result = await resolveWorkspaceMetroPort(root, note, "start");
+	return typeof result === "number" ? result : fail(result);
+}
+async function resolveWorkspaceMetroPort(root, note, command, reserve = true) {
+	const setting = metroPortSetting(root);
+	if (setting.error) return {
+		code: "STIM_BAD_ARG",
+		message: setting.error,
+		remedy: SETTING_SHAPE_REMEDY
+	};
+	const pinned = setting.port;
 	const project = getProject(root);
 	const recorded = project?.metroPort;
-	if (!recorded) return await reserveMetroPort(root);
-	const supervisor = resolveSupervisorTarget({
-		state: readWorkspaceState$1(root)?.supervisor,
-		record: project.supervisor,
-		reservedPort: recorded
-	});
-	if (supervisor.status !== "none" && supervisor.status !== "stale") return recorded;
-	const held = await resolveProjectMetro(recorded, root);
-	if (!held.notOurs) return recorded;
-	const fresh = await reserveMetroPort(root);
-	if (fresh !== recorded) {
-		note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
-		note(chalk.dim(`Reserved port ${fresh} for this project instead.`));
+	if (pinned === null && command === "web") return recorded ?? await reserveMetroPort(root);
+	if (recorded) {
+		const supervisor = resolveSupervisorTarget({
+			state: readWorkspaceState$1(root)?.supervisor,
+			record: project.supervisor,
+			reservedPort: recorded
+		});
+		if (supervisor.status !== "none" && supervisor.status !== "stale") {
+			if (pinned === null || recorded === pinned) return recorded;
+			if (supervisor.status === "unverified") return {
+				code: "STIM_BAD_ARG",
+				message: `Cannot move this workspace's Metro to metro.port ${pinned}: ${supervisor.reason}.`,
+				remedy: `Stop that supervisor with the tool that started it, then retry, or restore metro.port to ${recorded}. Stim leaves unverified processes alone.`
+			};
+			return {
+				code: "STIM_BAD_ARG",
+				message: `This workspace's dev server is running on port ${recorded}, and metro.port pins it to ${pinned}.`,
+				remedy: "Run `stim stop`, then retry, or unset or restore metro.port."
+			};
+		}
+	}
+	if (pinned !== null) {
+		const held = await resolveProjectMetro(pinned, root);
+		if (held.notOurs) return {
+			code: "STIM_BAD_ARG",
+			message: `Port ${pinned} is held by something else (${held.notOurs}), and metro.port pins this workspace's Metro to it.`,
+			remedy: "Stop the process on that port, or set another metro.port."
+		};
+		if (recorded === pinned) return recorded;
+	} else if (recorded) {
+		const held = await resolveProjectMetro(recorded, root);
+		if (!held.notOurs) return recorded;
+		const fresh = await reserveMetroPort(root);
+		if (fresh !== recorded) {
+			note(chalk.yellow(`Port ${recorded} is held by something else (${held.notOurs}).`));
+			note(chalk.dim(`Reserved port ${fresh} for this project instead.`));
+		}
+		return fresh;
+	}
+	if (!reserve && pinned !== null) return pinned;
+	try {
+		return await reserveMetroPort(root, void 0, void 0, pinned);
+	} catch (error) {
+		return {
+			code: "STIM_BAD_ARG",
+			message: error.message,
+			remedy: "Give each workspace its own metro.port, in the workspace layer or the environment."
+		};
 	}
-	return fresh;
 }
 async function waitForMetro({ root, port, seconds, aborted = () => false, probe = resolveProjectMetro }) {
 	const deadline = Date.now() + seconds * 1e3;
@@ -1014,17 +1062,20 @@ function failureEvidence({ logFile, logsDir, sinceTs }) {
 	if (recent.length > 0) lines.push(fellBack ? "Full records: `stim logs`" : "Full records: `stim logs --errors`");
 	return lines;
 }
-function report({ json, out, facts, waited, reclaimed }) {
+function report({ json, out, facts, waited, reclaimed, links }) {
 	if (json) {
-		console.log(JSON.stringify(reclaimed.length ? {
+		console.log(JSON.stringify({
 			...facts,
-			reclaimed
-		} : facts));
+			...links ? { links } : {},
+			...reclaimed.length ? { reclaimed } : {}
+		}));
 		return;
 	}
 	const who = facts.supervisorPid ? `supervisor pid ${facts.supervisorPid}${facts.mode ? ` (${facts.mode})` : ""}` : "started outside Stim";
 	out(chalk.green(`OK: dev server on port ${facts.port}, ${who}${facts.alreadyRunning ? " (already running)" : ""} ${waited}`));
 	out(chalk.dim(phaseLine("logs", facts.logsDir)));
+	if (facts.agentDevice) out(chalk.dim(phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${facts.agentDevice.stateDir}`)));
+	if (links) console.error(chalk.dim(workspaceLinkLine(links)));
 }
 //#endregion
-export { registerStart as a, startFacts as c, wantsExpoOwnTunnel as d, spawnEntry as f, detectBundleId as h, readLogTail as i, supervisorEntry as l, detectAppIds as m, liveSupervisor as n, startCommand as o, detectAndroidPackage as p, parseWait as r, startDevServer as s, failureEvidence as t, tailLines as u };
+export { registerStart as a, startDevServer as c, tailLines as d, wantsExpoOwnTunnel as f, detectBundleId as h, readLogTail as i, startFacts as l, detectAppIds as m, liveSupervisor as n, resolveWorkspaceMetroPort as o, detectAndroidPackage as p, parseWait as r, startCommand as s, failureEvidence as t, supervisorEntry as u };

package/dist/state-3DwSQIBK.mjs

@@ -0,0 +1,41 @@
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { join } from "node:path";
+import { readMacosRecord } from "@stim-cli/core/state";
+//#region src/macos/state.ts
+const macosDir = (root) => join(workspaceDir(root), "macos");
+const macosLogFile = (root) => join(workspaceLogsDir$1(root), "macos.ndjson");
+const macosRuntimeClaim = (root) => join(macosDir(root), "runtime.lock");
+function macosProcess(pid) {
+	const processToken = (0, process_identity_exports.captureProcessToken)(pid);
+	const start = (0, process_identity_exports.processStartMicros)(pid);
+	if (!processToken || start.status !== "running") throw Object.assign(/* @__PURE__ */ new Error(`Cannot verify macOS process ${pid}; refusing unmanaged launch.`), { code: "STIM_CLAIM_UNAVAILABLE" });
+	return {
+		pid,
+		processToken,
+		startedAtMicros: start.startedAtMicros
+	};
+}
+function requiredMacosRecord(root) {
+	const record = readMacosRecord(root);
+	if (!record && readWorkspaceState$1(root)?.macos !== void 0) throw Object.assign(/* @__PURE__ */ new Error("The recorded macOS owner is malformed; repair its workspace state before running."), { code: "STIM_MACOS_OWNER_UNVERIFIED" });
+	return record;
+}
+function updateMacosRecord(root, owner, patch) {
+	let updated = false;
+	updateWorkspaceState(root, (state) => {
+		const record = readMacosRecord(root);
+		if (!record || !(0, process_identity_exports.sameProcessRecord)(record.supervisor, owner)) return state;
+		updated = true;
+		return {
+			...state,
+			macos: {
+				...record,
+				...patch
+			}
+		};
+	});
+	return updated;
+}
+//#endregion
+export { requiredMacosRecord as a, macosRuntimeClaim as i, macosLogFile as n, updateMacosRecord as o, macosProcess as r, macosDir as t };

package/dist/state-B4PQFXMW.d.mts

@@ -0,0 +1,12 @@
+import "@stim-cli/core/state";
+import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
+//#endregion
+//#region src/supervisor/state.d.ts
+declare const MODE_BARE = "bare-inproc";
+declare const MODE_EXPO = "expo-child";
+declare function clearWorkspaceSupervisor(root: string, expected?: process_identity_d_exports.ProcessRecord | null): boolean;
+declare function clearExpoMetroTunnel(root: string): void;
+declare function writePidFile(root: string, pid: number): string;
+declare function readPidFile(root: string): number | null;
+//#endregion
+export { readPidFile as a, clearWorkspaceSupervisor as i, MODE_EXPO as n, writePidFile as o, clearExpoMetroTunnel as r, MODE_BARE as t };

package/dist/{state-Dk9RVXI7.mjs → state-C1jB7Q8q.mjs}

@@ -1,8 +1,10 @@
-import { A as ownership_claim_exports, O as process_identity_exports } from "./config-lvc7d3C2.mjs";
-import { M as workspaceLogsDir, _ as updateWorkspaceState, a as pidExists, b as writeWorkspaceState, h as readWorkspaceState$1, k as workspaceDir, p as clearWorkspaceStateKey } from "./metro-CcEo8Fl8.mjs";
-import { readlinkSync, rmSync } from "node:fs";
-import { WEB_VIEWPORTS } from "@stim-cli/core/state";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { o as pidExists } from "./metro-BeK1ZPz1.mjs";
+import { a as updateWorkspaceState, c as writeWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, v as workspaceDir, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { readFileSync, readlinkSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { rotatedLogPath } from "@stim-cli/core";
+import { WEB_VIEWPORTS } from "@stim-cli/core/state";
 import { hostname } from "node:os";
 //#region src/web/profile.ts
 const SINGLETON_FILES = [
@@ -56,13 +58,13 @@ function webClaimRoot(root) {
 	return join(webDir(root), "supervisor.lock");
 }
 function webLogFile(root) {
-	return join(workspaceLogsDir(root), "web.ndjson");
+	return join(workspaceLogsDir$1(root), "web.ndjson");
 }
 function webSupervisorLogFile(root) {
-	return join(workspaceLogsDir(root), "web-supervisor.log");
+	return join(workspaceLogsDir$1(root), "web-supervisor.log");
 }
 function browserLogFile(root) {
-	return join(workspaceLogsDir(root), "browser.log");
+	return join(workspaceLogsDir$1(root), "browser.log");
 }
 function processRecord(value) {
 	const record = value;
@@ -144,5 +146,65 @@ function webFacts(record) {
 		status: supervisor === "same" && chrome === "running" ? "running" : "orphaned"
 	};
 }
+const PAGE_FAILURES = /* @__PURE__ */ new Set(["web_document_failed", "web_page_crashed"]);
+const NAVIGATION = Buffer.from("\"event\":\"web_navigation\"");
+const PAGE_EVENT = "\"event\":\"web_";
+/**
+* The latest page load in the web log's `lines`: the newest `web_navigation` marker, whether a document failure, a
+* crash or the load event followed it, and the newest in-app route change after it. Null before the first
+* navigation.
+*/
+function latestPageLoad(lines) {
+	let failure = null;
+	let loaded = false;
+	let route = null;
+	for (let i = lines.length - 1; i >= 0; i--) {
+		let record;
+		try {
+			record = JSON.parse(lines[i]);
+		} catch {
+			continue;
+		}
+		if (record.event === "web_navigation" && typeof record.url === "string") {
+			const moved = route !== null && route !== record.url ? { route } : {};
+			if (failure !== null) return {
+				url: record.url,
+				state: "failed",
+				error: failure,
+				...moved
+			};
+			return {
+				url: record.url,
+				state: loaded ? "loaded" : "loading",
+				...moved
+			};
+		}
+		if (typeof record.event !== "string") continue;
+		if (record.event === "web_route" && typeof record.url === "string") route ??= record.url;
+		if (PAGE_FAILURES.has(record.event)) failure = typeof record.msg === "string" ? record.msg : record.event;
+		else if (record.event === "web_page_loaded") loaded = true;
+	}
+	return null;
+}
+/** The page lines from the newest navigation on, in the web log or, right after a rotation, its previous file. */
+function pageLines(file) {
+	for (const path of [file, rotatedLogPath(file)]) {
+		let bytes;
+		try {
+			bytes = readFileSync(path);
+		} catch {
+			continue;
+		}
+		const at = bytes.lastIndexOf(NAVIGATION);
+		if (at < 0) continue;
+		const start = bytes.lastIndexOf(10, at) + 1;
+		return bytes.subarray(start).toString("utf8").split("\n").filter((line) => line.includes(PAGE_EVENT));
+	}
+	return null;
+}
+function readWebPage(root) {
+	const lines = pageLines(webLogFile(root));
+	return lines ? latestPageLoad(lines) : null;
+}
 //#endregion
-export { readWebRecord as a, webDir as c, webProfileDir as d, webSupervisorLogFile as f, removeSingletonFiles as g, liveProfileHolder as h, clearWebRecord as i, webFacts as l, chromeProcessState as m, browserLogFile as n, updateWebRecord as o, writeWebRecord as p, cdpEndpoint as r, webClaimRoot as s, CDP_PORT_LABEL as t, webLogFile as u };
+export { removeSingletonFiles as _, readWebPage as a, webClaimRoot as c, webLogFile as d, webProfileDir as f, liveProfileHolder as g, chromeProcessState as h, clearWebRecord as i, webDir as l, writeWebRecord as m, browserLogFile as n, readWebRecord as o, webSupervisorLogFile as p, cdpEndpoint as r, updateWebRecord as s, CDP_PORT_LABEL as t, webFacts as u };

package/dist/{state-DHqvsbqC.mjs → state-DcW6vOd_.mjs}

@@ -1,5 +1,6 @@
-import { O as process_identity_exports, V as parseDeviceSlotKey, z as deviceSlotKey } from "./config-lvc7d3C2.mjs";
-import { D as supervisorPidFile, P as workspaceStateFile, _ as updateWorkspaceState, h as readWorkspaceState, p as clearWorkspaceStateKey, v as withWorkspaceStateLock } from "./metro-CcEo8Fl8.mjs";
+import { B as parseDeviceSlotKey, R as deviceSlotKey } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { C as workspaceStateFile, a as updateWorkspaceState, h as supervisorPidFile, o as withWorkspaceStateLock, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-B8-aJ1_5.mjs";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 //#region src/supervisor/state.ts
@@ -22,7 +23,7 @@ function readMetroTunnel(root) {
 		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;
+		if (provider !== "ngrok" && provider !== "cloudflared" && provider !== "tailscale" || typeof pid !== "number" || typeof port !== "number") return null;
 		return {
 			kind: "managed",
 			provider,
@@ -88,11 +89,13 @@ function readRemoteSession(root) {
 	const platform = record.platform;
 	const startedAt = record.startedAt;
 	const webPreviewUrl = record.webPreviewUrl;
+	const deviceType = record.deviceType;
 	return {
 		platform: platform === "ios" || platform === "android" ? platform : null,
 		sessionId: id,
 		startedAt: typeof startedAt === "string" ? startedAt : null,
-		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null
+		webPreviewUrl: typeof webPreviewUrl === "string" && webPreviewUrl.length > 0 ? webPreviewUrl : null,
+		deviceType: typeof deviceType === "string" && deviceType.length > 0 ? deviceType : null
 	};
 }
 function readRemoteSessionId(root) {

package/dist/stats-CEZ_i5je.mjs

@@ -0,0 +1,77 @@
+import { j as formatBytes } from "./config-D0DbpZtM.mjs";
+import { o as formatLongDuration } from "./command-output-DnJMdEY-.mjs";
+import { gt as repoRoot, it as gitCommonDir } from "./settings-oTSkkNrM.mjs";
+import { o as findProjectRoot$1 } from "./project-Du91Ilvc.mjs";
+import { i as getSwiftpmCacheUsage, n as swiftpmCacheLines, r as getAgentDeviceUsage, t as agentDeviceLines } from "./agent-device-usage-output-Dpih1Tfa.mjs";
+import { archivedUsage, readArchives, readStatsReport, statsProjectKey } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/stats.ts
+const PLATFORMS = ["ios", "android"];
+const PLATFORM_WIDTH = 9;
+const RECENT_PLACEMENTS = 5;
+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(async (opts) => {
+		const agentDevice = await getAgentDeviceUsage();
+		const swiftpmCache = await getSwiftpmCacheUsage();
+		const root = findProjectRoot$1(process.cwd());
+		const key = root ? statsProjectKey({
+			root,
+			commonDir: gitCommonDir(root),
+			repoRoot: repoRoot(root)
+		}) : null;
+		const { report, note } = readStatsReport(key, Date.now());
+		report.agentDevice = agentDevice;
+		report.swiftpmCache = swiftpmCache;
+		if (note) console.error(chalk.dim(note));
+		const { machine, project, offload } = report;
+		if (opts.json) {
+			console.log(JSON.stringify(report));
+			return;
+		}
+		const lines = [];
+		if (project) lines.push(`project ${project.key}`, ...sectionLines(project));
+		lines.push("machine", ...sectionLines(machine));
+		const usage = archivedUsage(readArchives());
+		lines.push("archive", `  archived workspaces: ${usage.count}, ${formatBytes(usage.bytes)}`);
+		if (offload.placements.length || Object.keys(offload.machines).length) lines.push(...placementLines(offload));
+		const agentLines = agentDeviceLines(report.agentDevice);
+		if (agentLines.length) lines.push(...agentLines, chalk.dim("  Stim never trims or deletes the shared runner builds, sessions, logs and other state or the hosted driver dir; a workspace's own agent-device dir goes only with its workspace."));
+		lines.push(...swiftpmCacheLines(report.swiftpmCache));
+		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 placementLines(offload) {
+	const { here, offloaded, fellBack } = offload.today;
+	const lines = ["build placement", `  ${"today".padEnd(PLATFORM_WIDTH)}${here} here, ${offloaded} offloaded, ${fellBack} fell back`];
+	for (const [name, { today, total }] of Object.entries(offload.machines)) {
+		const saved = total.savedMs === 0 ? "" : `, ${total.savedMs > 0 ? "saved" : "lost"} ~${formatLongDuration(Math.abs(total.savedMs))} (estimated)`;
+		lines.push(`  ${name}: today ${today.offloaded} offloaded, ${today.fallbacks} fell back; total ${total.offloaded} offloaded (${average(total.offloadedMs, total.offloaded)} avg)${saved}, ${total.fallbacks} fell back`);
+	}
+	for (const placement of offload.placements.slice(0, RECENT_PLACEMENTS)) {
+		const where = placement.decision === "here" ? "here" : `${placement.decision} ${placement.machine ?? ""}`.trim();
+		lines.push(chalk.dim(`  ${placement.at.slice(0, 16).replace("T", " ")}Z ${placement.platform} ${where}: ${placement.reason}`));
+	}
+	return lines;
+}
+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`,
+		...bucket.offloadedRuns ? [`offloaded run ${average(bucket.offloadedRunMs ?? 0, bucket.offloadedRuns)} avg (${bucket.offloadedRuns}, last on ${bucket.lastOffloadHost ?? "?"})`] : [],
+		`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 };