stim 1.17.2 → 1.19.0

package/dist/{trigger-Bemu8ytw.mjs → trigger-CAhmG-4s.mjs}

@@ -1,8 +1,8 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
-import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
-import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-Bk2ouQVL.mjs";
-import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-pB_IPfV4.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
 import { closeSync, openSync } from "node:fs";
 import { maintenanceChildLogFile, maintenanceRunClaims, readMaintenanceAttempt, readMaintenanceState } from "@stim-cli/core/state";
 import { readClaimSet } from "@stim-cli/core/ownership-claim";
@@ -14,7 +14,7 @@ function triggerMaintenance(trigger, { argv = process.argv.slice(2), platform =
 			"guide",
 			"settings",
 			"help"
-		].includes(argv[0] ?? "") || argv[0] === "gc" && argv.includes("--delete") || argv.some((arg) => [
+		].includes(argv[0] ?? "") || argv.includes("--plan") || argv[0] === "gc" && argv.includes("--delete") || argv.some((arg) => [
 			"--help",
 			"-h",
 			"--version",

package/dist/trigger-CoalsMTV.mjs

@@ -0,0 +1,2 @@
+import { t as triggerMaintenance } from "./trigger-CAhmG-4s.mjs";
+export { triggerMaintenance };

package/dist/{warm-progress-DF4JRvYI.mjs → warm-progress-pFLB2e6P.mjs}

@@ -1,14 +1,16 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
-import { o as pullRequestLookups } from "./pull-request-pxnDCQzn.mjs";
-import { at as gitCommonDirOnDisk } from "./settings-Cfd-0r2d.mjs";
-import { D as discoverAgentSessions, E as attributeAgentSessions, T as agentKey, a as updateWorkspaceState, u as ensureWorkspaceStorage, v as workspaceDir, w as withDirLock } from "./workspace-state-DqcCbpE7.mjs";
-import { I as ownedAvdDirectory } from "./android-B_YNZy61.mjs";
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { n as debugLog, t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { D as discoverAgentSessions, E as attributeAgentSessions, T as agentKey, a as updateWorkspaceState, u as ensureWorkspaceStorage, v as workspaceDir, w as withDirLock } from "./workspace-state-CR9X86xJ.mjs";
+import { ct as linkedWorktreesOnDisk, rt as gitCommonDirOnDisk } from "./settings-CxgngUZk.mjs";
+import { I as ownedAvdDirectory } from "./android-BdQC6zs1.mjs";
+import { o as pullRequestLookups } from "./pull-request-IHNdMnG8.mjs";
+import { existsSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, sep } from "node:path";
+import { ENDED_AGENT_RETENTION_MS, READY_PHASE_MS, WARM_KEY, agentSessionsCacheFile, diskUsageCacheFile, diskUsageFailureFile, diskUsageWalkClaims, pullRequestCacheFile, readAgentSessionsCache, readDiskUsage, readDiskUsageFailure, readEndedAgentSessions, readPullRequestCache, readWarmRecord, readWorkspaceAgent, readWorkspaceState, workspaceEndedAgentsFile, workspaceEndedAgentsLock } from "@stim-cli/core/state";
 import { homedir } from "node:os";
+import { clearClaimChild, markClaimChildPending, releaseClaim, setClaimChild, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
+import { captureProcessIdentity } from "@stim-cli/core/process-identity";
+import { randomUUID } from "node:crypto";
 //#region src/workspace/merge-state.ts
 const FETCH_TIMEOUT_MS = 3e4;
 const FETCH_FRESH_MS = 6e5;
@@ -282,6 +284,7 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS$1, maxComm
 const LIVE_DISK_MAX_AGE_MS = 3e5;
 const IDLE_DISK_MAX_AGE_MS = 36e5;
 const DU_TIMEOUT_MS = 12e4;
+const DU_NICENESS = "19";
 const PULL_REQUEST_MAX_AGE_MS = 3e5;
 const PULL_REQUEST_CHECK_MS = 6e4;
 const GIT_TIMEOUT_MS = 5e3;
@@ -301,8 +304,11 @@ function forgetStatusMeasures(worktree, workspaces) {
 	const roots = [.../* @__PURE__ */ new Set([worktree, ...workspaces])];
 	const files = [pullRequestCacheFile(worktree), ...roots.flatMap((root) => [
 		diskUsageCacheFile(root),
+		diskUsageFailureFile(root),
 		diskUsageCacheFile(join(root, "node_modules")),
-		diskUsageCacheFile(workspaceDir(root))
+		diskUsageFailureFile(join(root, "node_modules")),
+		diskUsageCacheFile(workspaceDir(root)),
+		diskUsageFailureFile(workspaceDir(root))
 	])];
 	for (const file of files) try {
 		rmSync(file, { force: true });
@@ -459,18 +465,63 @@ function applyStatusMeasures(states, worktrees) {
 		if (cached && cached.branch === worktree.branch) worktree.pullRequest = cached.pullRequest;
 	}
 }
-/** Kilobytes from `du -sk` output, or null when it printed none. */
+/** Kilobytes from `du -sk` output, summed over its lines, or null when it printed none. */
 function parseDuKilobytes(output) {
-	const kb = Number(/^(\d+)\s/.exec(output)?.[1]);
-	return Number.isFinite(kb) ? kb : null;
+	const sizes = [...output.matchAll(/^(\d+)\s/gm)].map((match) => Number(match[1]));
+	return sizes.length ? sizes.reduce((sum, kb) => sum + kb, 0) : null;
+}
+/** The folders inside a checkout that another measurement owns: its linked worktrees and Stim's workspace folder. */
+function nestedFolders(state) {
+	const common = gitCommonDirOnDisk(state.path);
+	return [workspaceDir(state.path), ...common ? linkedWorktreesOnDisk(common).map((entry) => entry.path) : []];
+}
+/** The entries to hand to `du` so it sums `root` without descending into `nested`; `[root]` when none is inside it. */
+function walkTargets(root, nested) {
+	const top = canonicalPath(root);
+	const skip = new Set(nested.map(canonicalPath));
+	const inside = [...skip].filter((path) => path.startsWith(top + sep));
+	if (!inside.length) return [root];
+	const targets = [];
+	const visit = (dir) => {
+		let names;
+		try {
+			names = readdirSync(dir);
+		} catch {
+			targets.push(dir);
+			return;
+		}
+		for (const name of names) {
+			const path = join(dir, name);
+			if (skip.has(path)) continue;
+			if (inside.some((nestedPath) => nestedPath.startsWith(path + sep))) visit(path);
+			else targets.push(path);
+		}
+	};
+	visit(top);
+	return targets;
 }
 function isStale(measure, maxAgeMs, now) {
 	return !measure || now - Date.parse(measure.measuredAt) >= maxAgeMs;
 }
+function takeWalkClaim() {
+	try {
+		const attempt = tryAcquireClaim({
+			root: diskUsageWalkClaims(),
+			mode: "exclusive",
+			label: "disk usage walk"
+		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		return attempt.acquired ?? null;
+	} catch (error) {
+		debugLog.log("disk-walk-claim", { error: String(error?.message ?? error) });
+		return null;
+	}
+}
 /**
 * Keeps the disk use, pull request and agent session caches fresh for `status --watch`, off its refresh path: one
 * agent session discovery at most every 15 seconds, which status ignores once it is over 2 minutes old, one `du -sk` at
-* a time, live environments first, each folder at most every 5 minutes while its environment is live and every hour otherwise, and one `gh api
+* a time on the whole machine (an ownership claim; a failed walk is recorded so other watchers do not repeat it), at low
+* priority, live environments first, a checkout without the linked worktrees nested in it, each folder at most every 5 minutes while its environment is live and every hour otherwise, and one `gh api
 * graphql` per repository for worktrees whose lookup is over 5 minutes old or whose branch or HEAD moved. It
 * runs git only in the repository, never in a worktree, and only for worktrees whose git state status read. It rechecks
 * a folder's cache right before measuring, so two watchers rarely measure the same folder. A session the previous
@@ -485,35 +536,77 @@ function createStatusMeasurer({ updated, now = Date.now }) {
 	let checkedAt = -Infinity;
 	let discovering = false;
 	let discoveredAt = -Infinity;
-	const failedAt = /* @__PURE__ */ new Map();
-	async function du(path) {
+	async function du(targets, claim) {
+		const hold = (child) => {
+			if (child.pid === void 0) return;
+			const captured = captureProcessIdentity(child.pid);
+			if (!captured.ok) throw new Error(`Cannot record the du process: ${captured.reason}`);
+			setClaimChild(claim, {
+				pid: child.pid,
+				processToken: captured.token
+			});
+		};
 		try {
-			return parseDuKilobytes(await exec.runFileAsync("du", ["-sk", path], { timeoutMs: DU_TIMEOUT_MS }));
+			markClaimChildPending(claim);
+			return parseDuKilobytes(await exec.runFileAsync("nice", [
+				"-n",
+				DU_NICENESS,
+				"du",
+				"-sk",
+				...targets
+			], {
+				timeoutMs: DU_TIMEOUT_MS,
+				onSpawn: hold
+			}));
 		} catch (error) {
 			const { code, status, stdout } = error;
 			if (code === "ENOENT") duMissing = true;
 			return status === 1 && typeof stdout === "string" ? parseDuKilobytes(stdout) : null;
+		} finally {
+			clearClaimChild(claim);
 		}
 	}
+	function due(path, maxAgeMs) {
+		const failedAt = readDiskUsageFailure(path);
+		return isStale(readDiskUsage(path), maxAgeMs, now()) && (!failedAt || now() - Date.parse(failedAt) >= maxAgeMs);
+	}
 	async function measure(folders) {
-		for (const { path, maxAgeMs } of folders) {
-			if (duMissing || !isStale(readDiskUsage(path), maxAgeMs, now())) continue;
-			if (now() - (failedAt.get(path) ?? -Infinity) < maxAgeMs) continue;
-			let bytes = 0;
-			if (existsSync(path)) {
-				const kb = await du(path);
-				if (kb === null) {
-					failedAt.set(path, now());
-					continue;
-				}
-				bytes = kb * 1024;
-			} else if (!basename(path).startsWith("node_modules")) continue;
-			writeCacheFile(diskUsageCacheFile(path), {
+		for (const { path, maxAgeMs, nested } of folders) {
+			if (duMissing || !due(path, maxAgeMs)) continue;
+			const stamp = () => ({
 				path,
-				bytes,
 				measuredAt: new Date(now()).toISOString()
 			});
-			updated();
+			if (!existsSync(path)) {
+				if (!basename(path).startsWith("node_modules")) continue;
+				writeCacheFile(diskUsageCacheFile(path), {
+					...stamp(),
+					bytes: 0
+				});
+				updated();
+				continue;
+			}
+			const claim = takeWalkClaim();
+			if (!claim) return;
+			try {
+				if (!due(path, maxAgeMs)) continue;
+				const targets = walkTargets(path, nested?.() ?? []);
+				const kb = targets.length ? await du(targets, claim) : 0;
+				if (kb === null) {
+					writeCacheFile(diskUsageFailureFile(path), {
+						path,
+						failedAt: new Date(now()).toISOString()
+					});
+					continue;
+				}
+				writeCacheFile(diskUsageCacheFile(path), {
+					...stamp(),
+					bytes: kb * 1024
+				});
+				updated();
+			} finally {
+				releaseClaim(claim);
+			}
 		}
 	}
 	async function branchHead(repository, branch) {
@@ -600,13 +693,17 @@ function createStatusMeasurer({ updated, now = Date.now }) {
 					...nodeModules,
 					build,
 					...deviceFolders(state).map((folder) => folder.path)
-				]) folders.set(path, Math.min(folders.get(path) ?? Infinity, maxAgeMs));
+				]) {
+					const known = folders.get(path);
+					folders.set(path, {
+						path,
+						maxAgeMs: Math.min(known?.maxAgeMs ?? Infinity, maxAgeMs),
+						nested: known?.nested ?? (path === worktree ? () => nestedFolders(state) : void 0)
+					});
+				}
 			}
 			measuring = true;
-			measure([...folders].map(([path, maxAgeMs]) => ({
-				path,
-				maxAgeMs
-			}))).catch(() => {}).finally(() => {
+			measure([...folders.values()]).catch(() => {}).finally(() => {
 				measuring = false;
 			});
 		}

package/dist/{status-CzS4bPO9.mjs → watchman-BL1IdOtq.mjs}

@@ -1,8 +1,9 @@
-import { H as projectDeviceSlots, R as deviceSlotKey } from "./config-D0DbpZtM.mjs";
-import { a as formatElapsed, o as formatLongDuration, r as clockTime, u as plural } from "./command-output-CDAIFD-8.mjs";
-import { n as isInsideProject } from "./metro-g8NqiJp-.mjs";
-import { g as workspaceAgentDeviceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { r as cdpEndpoint } from "./state-PeQiJuIu.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { a as formatElapsed, o as formatLongDuration, r as clockTime, u as plural } from "./command-output-Bt8ygHE7.mjs";
+import { H as projectDeviceSlots, R as deviceSlotKey } from "./config-DC5jEtd1.mjs";
+import { g as workspaceAgentDeviceDir } from "./workspace-state-CR9X86xJ.mjs";
+import { n as isInsideProject } from "./metro-DI2AjPF_.mjs";
+import { r as cdpEndpoint } from "./state-D2KtnALG.mjs";
 import { basename, sep } from "path";
 import { ACTIVITY_RECENCY_BASES } from "@stim-cli/core/state";
 //#region src/status.ts
@@ -153,7 +154,10 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 			startedAt: supervisor.startedAt ?? null,
 			healthy: Boolean(supervisor.healthy)
 		} : null,
-		agentDevice: { stateDir: workspaceAgentDeviceDir(project.__path) },
+		agentDevice: {
+			stateDir: workspaceAgentDeviceDir(project.__path),
+			installed: agentDeviceInstalled()
+		},
 		logs: logs ? {
 			dir: logs.dir,
 			errorsSinceMarker: logs.errorsSinceMarker ?? 0
@@ -432,5 +436,69 @@ function deviceLeaseLines(states, now) {
 	}
 	return lines;
 }
+const AGENT_DEVICE_CACHE_MS = 3e4;
+let agentDeviceCache;
+function agentDeviceInstalled() {
+	const now = Date.now();
+	const age = agentDeviceCache ? now - agentDeviceCache.at : -1;
+	if (agentDeviceCache && age >= 0 && age < AGENT_DEVICE_CACHE_MS) return agentDeviceCache.installed;
+	let installed = false;
+	try {
+		installed = Boolean(getExecutor().findExecutable("agent-device"));
+	} catch {
+		installed = false;
+	}
+	agentDeviceCache = {
+		at: now,
+		installed
+	};
+	return installed;
+}
+//#endregion
+//#region src/watchman.ts
+/** Runs one watchman command with `--no-spawn`, so Stim never starts a daemon, and parses its JSON answer. */
+const runWatchman = async (args, timeoutMs) => JSON.parse(await getExecutor().runFileAsync("watchman", ["--no-spawn", ...args], { timeoutMs }));
+function parseWatchRoots(payload) {
+	const roots = payload?.roots;
+	if (!Array.isArray(roots)) return null;
+	return roots.filter((root) => typeof root === "string");
+}
+function parseSubscriberNames(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const subscribers = payload.subscribers;
+	if (subscribers === void 0) return [];
+	if (!Array.isArray(subscribers)) return null;
+	const names = [];
+	for (const subscriber of subscribers) {
+		const name = subscriber?.info?.name;
+		if (typeof name !== "string") return null;
+		names.push(name);
+	}
+	return names;
+}
+function parseTriggerCount(payload) {
+	const triggers = payload?.triggers;
+	return Array.isArray(triggers) ? triggers.length : null;
+}
+function parseWatchmanPid(payload) {
+	const pid = payload?.pid;
+	return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+/** The connected clients in a `debug-status` answer, or null when the answer does not list them. */
+function parseWatchmanClients(payload) {
+	if (!payload || typeof payload !== "object" || "error" in payload) return null;
+	const clients = payload.clients;
+	if (!Array.isArray(clients)) return null;
+	const parsed = [];
+	for (const client of clients) {
+		const peer = client?.peer;
+		if (typeof peer?.pid !== "number") return null;
+		parsed.push({
+			pid: peer.pid,
+			name: typeof peer.name === "string" ? peer.name : null
+		});
+	}
+	return parsed;
+}
 //#endregion
-export { statusActivity as _, capacity as a, withWebFacts as b, diskLine as c, gitSummaryText as d, metroReverseTargets as f, remoteDeviceState as g, remoteDeviceLine as h, applyMachineMemory as i, environmentState as l, poolLine as m, activityLabel as n, deviceLeaseLines as o, parseDfFree as p, addReverseMissingIssue as r, deviceLeaseStates as s, RECENT_LAUNCH_MS as t, formatSpace as u, tightVolumes as v, unprovisionedWorktrees as y };
+export { statusActivity as C, withWebFacts as E, remoteDeviceState as S, unprovisionedWorktrees as T, gitSummaryText as _, parseWatchmanPid as a, poolLine as b, activityLabel as c, capacity as d, deviceLeaseLines as f, formatSpace as g, environmentState as h, parseWatchmanClients as i, addReverseMissingIssue as l, diskLine as m, parseTriggerCount as n, runWatchman as o, deviceLeaseStates as p, parseWatchRoots as r, RECENT_LAUNCH_MS as s, parseSubscriberNames as t, applyMachineMemory as u, metroReverseTargets as v, tightVolumes as w, remoteDeviceLine as x, parseDfFree as y };

package/dist/web-DFpFeZu5.mjs

@@ -0,0 +1,2 @@
+import { n as webCommand, t as runWeb } from "./web-DbbrPUn0.mjs";
+export { webCommand as default, runWeb };

package/dist/web-DbbrPUn0.mjs

@@ -0,0 +1,127 @@
+import { f as refuseNoProject, l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
+import { E as upsertProject, p as getProject } from "./config-DC5jEtd1.mjs";
+import { i as recordWorkspaceUse, x as workspaceLogsDir } from "./workspace-state-CR9X86xJ.mjs";
+import { d as projectRegistry, n as findCommandWorkspace } from "./project-B5eQ1USs.mjs";
+import { B as settingShapeErrors, I as resolveSettings, i as SETTING_SHAPE_REMEDY, mt as repoRoot, nt as gitCommonDir } from "./settings-CxgngUZk.mjs";
+import { o as readWebRecord, r as cdpEndpoint } from "./state-D2KtnALG.mjs";
+import { a as workspaceLinks, i as workspaceLinkLine } from "./stim-desktop-C65jk_q2.mjs";
+import { n as ensureWorkspaceStorageSafely } from "./native-runtime-BGxsbfny.mjs";
+import { t as liveWebRecord } from "./page-Bv9s2KwY.mjs";
+import chalk from "chalk";
+//#region src/commands/web.ts
+const printNote = (line) => console.error(line);
+async function runWeb({ root, headed, note }) {
+	const startedAt = Date.now();
+	await ensureWorkspaceStorageSafely(root, { note });
+	if (!getProject(root)) upsertProject(root, {});
+	const settings = resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root)
+	});
+	const [shapeError] = settingShapeErrors(settings);
+	if (shapeError) return {
+		ok: false,
+		error: {
+			code: "STIM_BAD_ARG",
+			message: shapeError,
+			remedy: SETTING_SHAPE_REMEDY
+		}
+	};
+	const selected = projectRegistry.selectWeb(root);
+	if ("problem" in selected) {
+		const { message, remedy } = selected.problem;
+		return {
+			ok: false,
+			error: {
+				code: "STIM_NO_PROJECT",
+				message,
+				remedy
+			}
+		};
+	}
+	const runtime = (await selected.load()).runtime({
+		settings,
+		headed,
+		note
+	});
+	const preparation = await runtime.prepare();
+	if (!preparation.ok) return {
+		ok: false,
+		error: {
+			...preparation.error,
+			remedy: preparation.error.remedy ?? null
+		}
+	};
+	const { prepared } = preparation;
+	const { url } = prepared;
+	const launch = await runtime.launch(prepared, {
+		root,
+		note
+	});
+	if (!launch.ok) return launch;
+	const { verdict, remedy } = await runtime.verify(prepared, { since: launch.since });
+	const live = liveWebRecord(readWebRecord(root));
+	const record = live ?? launch.record;
+	return {
+		ok: true,
+		remedy,
+		facts: {
+			platform: "web",
+			browser: "chrome",
+			version: record.version ?? null,
+			running: live !== null,
+			pid: live?.chromeProcess?.pid ?? null,
+			supervisorPid: live?.pid ?? null,
+			url,
+			headless: record.headless,
+			viewport: record.viewport,
+			profile: record.profile,
+			cdpEndpoint: live ? cdpEndpoint(live.cdpPort) : null,
+			targetId: live?.targetId ?? null,
+			reused: launch.reused,
+			launched: verdict.launched,
+			metroPort: prepared.metroPort,
+			logs: { dir: workspaceLogsDir(root) },
+			durationMs: Date.now() - startedAt
+		}
+	};
+}
+function webCommand(program) {
+	program.command("web").description("Open this workspace's page in a Stim-owned headless Chrome and capture its console, errors and failed requests in stim logs").option("--headed", "Show the Chrome window instead of running headless").option("--json", "Print the result as one JSON object; progress goes to stderr").action(async (opts) => {
+		const json = Boolean(opts.json);
+		const root = findCommandWorkspace(process.cwd());
+		if (!root) {
+			refuseNoProject({ json });
+			return;
+		}
+		recordWorkspaceUse(root);
+		const result = await runWeb({
+			root,
+			headed: Boolean(opts.headed),
+			note: printNote
+		});
+		if (!result.ok) {
+			printNote(chalk.red(phaseLine("error", `${result.error.code}: ${result.error.message}`)));
+			if (result.error.remedy) printNote(phaseLine("remedy", result.error.remedy));
+			if (json) console.log(JSON.stringify(result.error));
+			process.exitCode = 1;
+			return;
+		}
+		const { facts, remedy } = result;
+		if (remedy) printNote(chalk.yellow(phaseLine("launch", remedy)));
+		const links = workspaceLinks(root, { platform: "web" });
+		if (json) {
+			console.log(JSON.stringify(links ? {
+				...facts,
+				links
+			} : facts));
+			return;
+		}
+		const launched = facts.launched === true ? chalk.green("loaded") : chalk.yellow(facts.launched === "bundling" ? "bundling" : "unverified");
+		console.log(facts.running ? `${facts.url} ${launched} in ${facts.version ?? "Chrome"} (pid ${facts.pid}, ${facts.headless ? "headless" : "headed"}, ${facts.viewport}). DevTools: ${facts.cdpEndpoint}. Logs: stim logs --errors.` : `${facts.url} ${launched}, and the owned Chrome is no longer running. Run stim logs --errors, then stim web again.`);
+		if (links) console.error(chalk.dim(workspaceLinkLine(links)));
+	});
+}
+//#endregion
+export { webCommand as n, runWeb as t };

package/dist/web-run.mjs

@@ -1,18 +1,18 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
-import { u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
-import { _ as removeSingletonFiles, c as webClaimRoot, d as webLogFile, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, l as webDir, m as writeWebRecord, n as browserLogFile, s as updateWebRecord } from "./state-PeQiJuIu.mjs";
-import { c as probeWebDrivers } from "./activity-IRvJY_ru.mjs";
-import { r as recordCreatedDevice } from "./created-devices-CpvzBL25.mjs";
-import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { d as signalProcessTree } from "./metro-DI2AjPF_.mjs";
+import { _ as removeSingletonFiles, c as webClaimRoot, d as webLogFile, f as webProfileDir, g as liveProfileHolder, h as chromeProcessState, i as clearWebRecord, l as webDir, m as writeWebRecord, n as browserLogFile, s as updateWebRecord } from "./state-D2KtnALG.mjs";
+import { c as probeWebDrivers } from "./activity-BSw0x84R.mjs";
+import { r as recordCreatedDevice } from "./created-devices-D0s26Hx5.mjs";
+import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-pB_IPfV4.mjs";
 import { t as connectOwnedBrowser } from "./cdp-Dq_ypAlJ.mjs";
-import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-BrcVWQyD.mjs";
+import { i as chromeArgs, n as DESKTOP_PAGE, r as PHONE_SCREEN } from "./chrome-BTUOo8p2.mjs";
 import { existsSync, mkdirSync, openSync, realpathSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
-import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { WEB_VIEWPORTS } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 //#region src/web/events.ts
 const MAX_FRAMES = 20;
 const CONSOLE_LEVELS = {

package/dist/{workspace-state-DqcCbpE7.mjs → workspace-state-CR9X86xJ.mjs}

@@ -1,11 +1,11 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { join as join$1, resolve as resolve$1 } from "path";
-import { buildCacheRoot as sharedBuildCache, withDirLock as withDirLock$1, workspaceId as workspaceId$1, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
 import { WORKSPACE_AGENT_KEY, emulatorLogFile, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache as sharedCcache$1, sharedCompilationCache as sharedCompilationCache$1, supervisorLogFile, supervisorPidFile, workspaceAgentDeviceDir, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir as workspaceLogsDir$1, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
 import { homedir } from "node:os";
+import { buildCacheRoot as sharedBuildCache, withDirLock as withDirLock$1, workspaceId as workspaceId$1, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
 import { readFile, readdir } from "node:fs/promises";
 //#region src/agent-sessions.ts
 const TITLE_MAX_LENGTH = 120;