stim 1.13.0 → 1.15.0

package/dist/{status-sszP4XKU.mjs → status-l84Gbvp2.mjs}

@@ -1,7 +1,9 @@
-import { U as projectDeviceSlots, z as deviceSlotKey } from "./config-0jCcMM0E.mjs";
-import { a as formatElapsed, o as formatLongDuration, r as clockTime, u as plural } from "./command-output-BIL7rlX7.mjs";
-import { r as cdpEndpoint } from "./state-l1pYwOre.mjs";
-import { sep } from "path";
+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-CliHHn7a.mjs";
+import { n as isInsideProject } from "./metro-Di8EN2Tb.mjs";
+import { r as cdpEndpoint } from "./state-DFm77wRn.mjs";
+import { basename, sep } from "path";
+import { ACTIVITY_RECENCY_BASES } from "@stim-cli/core/state";
 //#region src/status.ts
 const IOS_SIM_MB = 1500;
 const ANDROID_EMULATOR_MB = 2500;
@@ -31,7 +33,7 @@ function avdExpected({ slot, serial, launches, leasedIds, running, now }) {
 	if (!launch) return false;
 	return running || now - Date.parse(launch.launchedAt) < 18e5;
 }
-function androidStatus(android, androidRuntime, androidDeviceProfile) {
+function androidStatus(android, androidRuntime, androidDeviceProfile, facts) {
 	if (!android) return null;
 	return {
 		name: android.avdName ?? android.serial,
@@ -41,10 +43,20 @@ function androidStatus(android, androidRuntime, androidDeviceProfile) {
 			serial: androidRuntime.serial,
 			state: androidRuntime.state
 		} : {},
-		...androidDeviceProfile ? { deviceProfile: androidDeviceProfile } : {}
+		...androidDeviceProfile ? { deviceProfile: androidDeviceProfile } : {},
+		...facts
 	};
 }
-function environmentState(project, { simsByUdid = {}, metro = null, worktrees = [], simsAvailable = true, androidRuntime = null, androidRuntimes = {}, androidDeviceProfile = null, androidDeviceProfiles = {}, supervisor = null, logs = null, remote = null, idleStop = null, launches = {}, leasedIds = /* @__PURE__ */ new Set(), now = Date.now(), slot = "default", workspaceRunning = false } = {}) {
+function idleShutdownFact(stopped, record) {
+	return stopped && record ? { idleShutdown: record } : {};
+}
+function stoppedMetroFacts(idleStop, lastStop) {
+	return {
+		...idleStop ? { idleStop } : {},
+		...lastStop ? { lastStop } : {}
+	};
+}
+function environmentState(project, { simsByUdid = {}, metro = null, worktrees = [], simsAvailable = true, androidRuntime = null, androidRuntimes = {}, androidDeviceProfile = null, androidDeviceProfiles = {}, supervisor = null, logs = null, remote = null, idleStop = null, lastStop = null, idleShutdowns = {}, launches = {}, leasedIds = /* @__PURE__ */ new Set(), now = Date.now(), slot = "default", workspaceRunning = false, workspaces } = {}) {
 	const ios = project.platforms?.ios;
 	const android = project.platforms?.android;
 	const sim = ios ? simsByUdid[ios.deviceUdid] : null;
@@ -67,9 +79,9 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 		...slot === "default" ? {} : { slot }
 	});
 	const slotFlag = slot === "default" ? "" : ` --slot ${slot}`;
-	if (metro?.notOurs && slot === "default") add("port-not-ours", `port ${project.metroPort}: ${metro.notOurs}`, "stim guide errors teardown", "error");
-	if (ios && !sim && simsAvailable) add("sim-missing", `recorded sim ${ios.deviceUdid} no longer exists`, `stim ios${slotFlag}`);
-	if (simBooted && project.metroPort && !metroRunning) add("sim-without-metro", "simulator is booted with no Metro serving it", "stim start");
+	if (metro?.notOurs && slot === "default") add("port-not-ours", ...portNotOurs(project.metroPort, portHolder(metro.cwd, project.__path, workspaces), supervisor));
+	if (ios && !sim && simsAvailable) add("sim-missing", `recorded sim ${ios.deviceUdid} no longer exists`, `stim ios${slotFlag}`, "info");
+	if (simBooted && project.metroPort && !metroRunning) add("sim-without-metro", "simulator is booted with no Metro serving it", "stim start", "info");
 	if (androidRuntime && android?.avdName) {
 		const recordedSerial = android.consolePort ? `emulator-${android.consolePort}` : android.serial;
 		const expected = avdExpected({
@@ -80,7 +92,7 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 			running,
 			now
 		});
-		for (const [code, message] of androidIssues(android, recordedSerial, androidRuntime, expected)) add(code, message, code === "avd-unchecked" ? "stim doctor" : `stim android${slotFlag}`);
+		for (const [code, message, severity] of androidIssues(android, recordedSerial, androidRuntime, expected)) add(code, message, code === "avd-unchecked" ? "stim doctor" : `stim android${slotFlag}`, severity);
 	}
 	if (supervisor?.status === "unverified") add("supervisor-unverified", `supervisor pid ${supervisor.pid} could not be verified${supervisor.reason ? `: ${supervisor.reason}` : ""}`, "stim guide errors teardown", "error");
 	const slots = [];
@@ -95,6 +107,7 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 			metro,
 			androidRuntime: androidRuntimes[name],
 			androidDeviceProfile: androidDeviceProfiles[name],
+			idleShutdowns,
 			launches,
 			leasedIds,
 			now,
@@ -115,20 +128,23 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 		...slots.length ? { slots } : {},
 		live,
 		memoryMb,
-		warnings: issues.map(issueText),
+		memorySource: "estimate",
+		warnings: warningTexts(issues),
 		issues,
 		ios: ios ? {
 			name: sim?.name ?? null,
 			udid: ios.deviceUdid,
 			owned: Boolean(ios.owned),
-			state: sim?.state ?? (simsAvailable ? "missing" : "unknown")
+			state: sim?.state ?? (simsAvailable ? "missing" : "unknown"),
+			...idleShutdownFact(!simBooted && sim, idleShutdowns[deviceSlotKey("ios", slot)])
 		} : null,
-		android: androidStatus(android, androidRuntime, androidDeviceProfile),
+		android: androidStatus(android, androidRuntime, androidDeviceProfile, idleShutdownFact(!androidDetected, idleShutdowns[deviceSlotKey("android", slot)])),
 		metro: project.metroPort ? {
 			port: project.metroPort,
 			running: metroRunning,
 			pid: metro?.metro?.pid ?? null,
-			...idleStop && !metroRunning ? { idleStop } : {}
+			...metroRunning ? {} : stoppedMetroFacts(idleStop, lastStop),
+			...portHeldBy(metro)
 		} : null,
 		supervisor: supervisor && supervisor.status !== "stale" ? {
 			pid: supervisor.pid ?? null,
@@ -144,6 +160,14 @@ function environmentState(project, { simsByUdid = {}, metro = null, worktrees =
 		remoteDevices: remote ? [remote] : []
 	};
 }
+/** Sets each environment's `memoryMb` to the sum of its owners' footprints; without footprints it keeps the estimate. */
+function applyMachineMemory(states, machine) {
+	if (machine.memorySource !== "footprint") return;
+	for (const state of states) {
+		state.memoryMb = machine.owners.reduce((sum, owner) => owner.workspace === state.path ? sum + owner.memoryMb : sum, 0);
+		state.memorySource = machine.memorySource;
+	}
+}
 /** Adds the workspace's owned Chrome to its status: the web entry, its memory, and an unverifiable browser. */
 function withWebFacts(state, web) {
 	if (!web) return state;
@@ -167,7 +191,7 @@ function withWebFacts(state, web) {
 		...state,
 		live: state.live || running || web.status === "orphaned",
 		memoryMb: state.memoryMb + (running || web.status === "orphaned" ? BROWSER_MB : 0),
-		warnings: issues.map(issueText),
+		warnings: warningTexts(issues),
 		issues,
 		web: webBrowserState(web)
 	};
@@ -184,20 +208,94 @@ function webBrowserState({ record, status }) {
 		headless: record.headless,
 		viewport: record.viewport,
 		profile: record.profile,
-		cdpEndpoint: running ? cdpEndpoint(record.cdpPort) : null
+		cdpEndpoint: running ? cdpEndpoint(record.cdpPort) : null,
+		targetId: running ? record.targetId ?? null : null
 	};
 }
 function androidIssues(android, recordedSerial, runtime, expected) {
 	const issues = [];
 	if (runtime.serial && recordedSerial && runtime.serial !== recordedSerial) issues.push(["avd-serial-changed", `owned AVD ${android.avdName} changed serial (${recordedSerial} -> ${runtime.serial}), so Metro forwarding is lost; rerun with the same build options, then reopen agent-device on ${runtime.serial}`]);
-	if (runtime.state === "missing") issues.push(["avd-missing", `recorded AVD ${android.avdName} no longer exists`]);
+	if (runtime.state === "missing") issues.push([
+		"avd-missing",
+		`recorded AVD ${android.avdName} no longer exists`,
+		"info"
+	]);
 	if (runtime.state === "not-detected" && expected) issues.push(["avd-not-detected", `owned AVD ${android.avdName} is not detected by adb`]);
 	if (runtime.error) issues.push(["avd-unchecked", `could not check owned AVD ${android.avdName}: ${runtime.error}`]);
 	return issues;
 }
+/**
+* The owned emulators worth an `adb reverse --list`: each runs this workspace's debug app, launched onto that serial
+* against the Metro port that is serving now.
+*/
+function metroReverseTargets(state, launches) {
+	const metroPort = state.metro?.running ? state.metro.port : null;
+	if (!metroPort) return [];
+	return [{
+		slot: "default",
+		android: state.android
+	}, ...state.slots ?? []].flatMap(({ slot, android }) => {
+		const launch = launches[deviceSlotKey("android", slot)];
+		if (!android?.owned || android.physical || !android.serial || android.app?.state !== "running") return [];
+		if (!launch || launch.release || launch.metroPort !== metroPort || launch.deviceId !== android.serial) return [];
+		return [{
+			slot,
+			serial: android.serial,
+			metroPort
+		}];
+	});
+}
+function addReverseMissingIssue(state, { slot, serial, metroPort }) {
+	const issue = {
+		code: "android-reverse-missing",
+		severity: "warning",
+		message: `the adb reverse for Metro port ${metroPort} is missing on ${serial}, so the app cannot reach Metro`,
+		remedy: "stim reload android",
+		workspace: state.path,
+		...slot === "default" ? {} : { slot }
+	};
+	state.issues.push(issue);
+	state.warnings.push(issueText(issue));
+}
+function portNotOurs(port, holder, supervisor) {
+	if (supervisor?.status === "ours") return [
+		`port ${port} is in use by ${holder}, so this workspace's Metro cannot serve on it`,
+		"stim stop",
+		"warning"
+	];
+	if (supervisor?.status === "unverified") return [
+		`port ${port} is in use by ${holder}`,
+		"stim guide errors teardown",
+		"warning"
+	];
+	return [
+		`port ${port} is in use by ${holder}; stim start will choose a free port`,
+		"stim start",
+		"info"
+	];
+}
+function portHeldBy(metro) {
+	return metro?.notOurs && metro.pid ? { heldBy: {
+		pid: metro.pid,
+		cwd: metro.cwd ?? null
+	} } : {};
+}
+function warningTexts(issues) {
+	return issues.filter((issue) => issue.severity !== "info").map(issueText);
+}
+function portHolder(cwd, self, workspaces = []) {
+	if (!cwd) return "another app";
+	const owner = workspaces.filter((path) => path !== self && isInsideProject(cwd, path)).toSorted((a, b) => b.length - a.length)[0];
+	if (owner) return `Metro for workspace ${basename(owner)}`;
+	return `a dev server in ${cwd.split(/[\\/]/).filter(Boolean).slice(-3).join("/")}`;
+}
 function issueText(issue) {
 	return `${issue.slot ? `${issue.slot}: ` : ""}${issue.message}; run \`${issue.remedy}\``;
 }
+function toMinute(iso) {
+	const time = Date.parse(iso);
+	return (/* @__PURE__ */ new Date(time - time % 6e4)).toISOString();
+}
 /**
 * Activity as status reports it: `lastActivityAt` rounded down to the minute, the precision its readers show, so a
 * new log record within the same minute does not change the payload.
@@ -207,7 +305,11 @@ function statusActivity(activity) {
 	if (!Number.isFinite(at)) return activity;
 	return {
 		...activity,
-		lastActivityAt: (/* @__PURE__ */ new Date(at - at % 6e4)).toISOString()
+		lastActivityAt: toMinute(activity.lastActivityAt),
+		...activity.recent ? { recent: Object.fromEntries(ACTIVITY_RECENCY_BASES.flatMap((basis) => {
+			const iso = activity.recent?.[basis];
+			return iso ? [[basis, toMinute(iso)]] : [];
+		})) } : {}
 	};
 }
 function activityLabel(activity, now) {
@@ -329,4 +431,4 @@ function deviceLeaseLines(states, now) {
 	return lines;
 }
 //#endregion
-export { withWebFacts as _, deviceLeaseStates as a, formatSpace as c, poolLine as d, remoteDeviceLine as f, unprovisionedWorktrees as g, tightVolumes as h, deviceLeaseLines as i, gitSummaryText as l, statusActivity as m, activityLabel as n, diskLine as o, remoteDeviceState as p, capacity as r, environmentState as s, RECENT_LAUNCH_MS as t, parseDfFree as u };
+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 };

package/dist/stdout-reader-C8yjre1x.mjs

@@ -0,0 +1,23 @@
+import { fstatSync } from "node:fs";
+//#region src/stdout-reader.ts
+const READER_CHECK_MS = 2e3;
+/**
+* Calls `onGone` once the process reading stdout is gone, for a streaming command that can stay quiet for a long
+* time. Returns a function that stops watching.
+*/
+function watchStdoutReader(onGone) {
+	const parent = process.ppid;
+	const stdout = fstatSync(1);
+	const linuxPipe = process.platform === "linux" && (stdout.isFIFO() || stdout.isSocket());
+	const timer = setInterval(() => {
+		if (linuxPipe && process.ppid !== parent) onGone();
+		else process.stdout.write("");
+	}, READER_CHECK_MS);
+	process.stdout.on("error", onGone);
+	return () => {
+		clearInterval(timer);
+		process.stdout.off("error", onGone);
+	};
+}
+//#endregion
+export { watchStdoutReader as t };

package/dist/stim-desktop-Cnz8CPnl.mjs

@@ -0,0 +1,63 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+//#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);
+}
+function launchServicesFinds(script) {
+	return Boolean(getExecutor().runFileQuiet("osascript", [
+		"-l",
+		"JavaScript",
+		"-e",
+		script
+	], {
+		timeoutMs: 5e3,
+		killSignal: "SIGKILL"
+	}));
+}
+function stimDesktopHandlesLinks(platform = process.platform, env = process.env) {
+	if (platform !== "darwin") return false;
+	if (env.STIM_DESKTOP_APP) return true;
+	return launchServicesFinds(SCHEME_HANDLER_LOOKUP);
+}
+/**
+* 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.
+*/
+function workspaceLinks(root, target, handlesLinks = stimDesktopHandlesLinks) {
+	if (!handlesLinks()) return void 0;
+	let desktop = `stim-desktop://workspace?path=${linkParam(root)}`;
+	if (target) desktop += `&platform=${target.platform}`;
+	if (target?.slot && target.slot !== "default") desktop += `&slot=${linkParam(target.slot)}`;
+	return { desktop };
+}
+const linkParam = (value) => encodeURIComponent(value).replaceAll("%2F", "/");
+function workspaceLinkLine(links) {
+	return `Open in Stim Desktop: ${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 { workspaceLinks as a, workspaceLinkLine as i, settingDefault as n, stimDesktopInstalled as r, STIM_DESKTOP_OPEN_OPTIONS as t };

package/dist/stim-footprint.swift

@@ -0,0 +1,32 @@
+// Prints "<pid> <bytes>" for each pid, the pid's physical footprint: the value Activity Monitor's Memory column and
+// top's MEM column show. With no arguments it reads every pid proc_listallpids(3) returns.
+//
+// The footprint comes from proc_pid_rusage(pid, RUSAGE_INFO_V4, ...) in <libproc.h>, field ri_phys_footprint of
+// struct rusage_info_v4 in <sys/resource.h> (macOS 10.14+). The call fails with EPERM for another user's process
+// unless the caller is root, and with ESRCH for a pid that has exited; those pids are left out of the output.
+
+import Darwin
+
+func allPids() -> [pid_t] {
+  var capacity = Int(proc_listallpids(nil, 0)) + 64
+  while true {
+    var pids = [pid_t](repeating: 0, count: capacity)
+    let count = pids.withUnsafeMutableBytes { proc_listallpids($0.baseAddress, Int32($0.count)) }
+    if count < 0 { return [] }
+    if Int(count) < capacity { return Array(pids.prefix(Int(count))) }
+    capacity *= 2
+  }
+}
+
+let arguments = CommandLine.arguments.dropFirst()
+let pids = arguments.isEmpty ? allPids() : arguments.compactMap { pid_t($0) }
+var output = ""
+output.reserveCapacity(pids.count * 20)
+var info = rusage_info_v4()
+for pid in pids where pid > 0 {
+  let status = withUnsafeMutablePointer(to: &info) {
+    $0.withMemoryRebound(to: rusage_info_t?.self, capacity: 1) { proc_pid_rusage(pid, RUSAGE_INFO_V4, $0) }
+  }
+  if status == 0 { output += "\(pid) \(info.ri_phys_footprint)\n" }
+}
+fputs(output, stdout)

package/dist/{stim-installations-CINXy_su.mjs → stim-installations-QMEI32v1.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, join, resolve } from "node:path";
 //#region src/diagnostics/stim-installations.ts

package/dist/{stop-BZ2qMiBP.mjs → stop-Bad61z_2.mjs}

@@ -1,14 +1,19 @@
-import { A as ownership_claim_exports, B as deviceSlotPlatforms, E as withConfigLock, G as validateDeviceSlot, H as parseDeviceSlotOption, O as process_identity_exports, T as upsertProject, U as projectDeviceSlots, V as parseDeviceSlotKey, o as clearSupervisor, p as getProject } from "./config-0jCcMM0E.mjs";
-import { a as pidExists, b as writeWorkspaceState, c as resolveProjectMetro, h as readWorkspaceState, k as workspaceDir, l as signalProcessTree, m as clearWorkspaceStateKeys, n as killMetroTree, v as withWorkspaceStateLock } from "./metro-BPeY1YMh.mjs";
-import { i as findCommandWorkspace } from "./project-DGeclhvO.mjs";
-import { a as clearRemoteSession, c as readMetroTunnel, i as clearManagedMetroTunnel, o as clearWorkspaceLaunches, s as clearWorkspaceSupervisor, u as readRemoteSession } from "./state-DwAU2_-D.mjs";
-import { a as withWorkspaceProcessLock } from "./named-ports-n7tnJsI8.mjs";
-import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-BIL7rlX7.mjs";
-import { u as releaseWorkspaceLeases } from "./device-lease-CL9dZf73.mjs";
-import { f as teardownOwnedAvd, i as stopTunnel, m as teardownOwnedIosSim, p as teardownOwnedBrowser, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-Bz2kETAS.mjs";
-import { f as resolveEasCliBin } from "./remote-cache--aehr4Pr.mjs";
-import { _ as describeNativeRunHolder, b as requestNativeRunCancel, f as NATIVE_RUN_LOCK, g as decideStopAction, h as clearNativeRunCancel, i as endRecordedSession, p as NATIVE_RUN_WAIT_MS, v as nativeRunHolder, y as nativeRunWaitNotice } from "./device-remote-DT9ngZiD.mjs";
+import { B as parseDeviceSlotKey, D as withConfigLock, E as upsertProject, H as projectDeviceSlots, V as parseDeviceSlotOption, W as validateDeviceSlot, o as clearSupervisor, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { b as workspaceDir, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-CL2V2Ons.mjs";
+import { i as findCommandWorkspace } from "./project-CV3tDFHl.mjs";
+import { a as clearRemoteSession, c as readMetroTunnel, i as clearManagedMetroTunnel, o as clearWorkspaceLaunches, s as clearWorkspaceSupervisor, u as readRemoteSession } from "./state-CaeaHbDA.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-CliHHn7a.mjs";
+import { n as fileLeaseIo, u as releaseWorkspaceLeases } from "./device-lease-W5Pi1q38.mjs";
+import { l as resolveProjectMetro, o as pidExists, r as killMetroTree, u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
+import { a as teardownOwnedBrowser, i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-BYuQafiA.mjs";
+import { a as logVanishedSupervisor, l as withdrawDevServerStopRequest, p as stopTunnel, s as requestDevServerStop, u as resolveSupervisorTarget } from "./stop-cause-CZ_Mr-v9.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-BkYxUtuj.mjs";
+import { t as stopMacosApp } from "./stop-Bvf1MflS.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-CO2elm_b.mjs";
+import { i as endRecordedSession } from "./device-remote-9ulPsdhY.mjs";
+import { a as decideStopAction, c as nativeRunWaitNotice, i as clearNativeRunCancel, l as requestNativeRunCancel, n as NATIVE_RUN_WAIT_MS, o as describeNativeRunHolder, s as nativeRunHolder, t as NATIVE_RUN_LOCK } from "./native-run-DFDoIRbY.mjs";
 import chalk from "chalk";
 //#region src/commands/stop.ts
 const DEFAULT_WAIT_MS = 1e4;
@@ -121,6 +126,7 @@ function remoteEnded(entry) {
 }
 async function runStop(options) {
 	if (options.slot === void 0) return stopWorkspace(options);
+	if (options.slot === "web") return stopBrowserOnly(options);
 	const slot = validateDeviceSlot(options.slot);
 	const root = options.root;
 	const project = options.project === void 0 ? getProject(root) : options.project;
@@ -149,6 +155,7 @@ async function runStop(options) {
 		},
 		clearRegistration: async () => true,
 		teardownBrowser: null,
+		stopMacos: false,
 		releaseLeases: (projectRoot) => releaseWorkspaceLeases(projectRoot, { slot })
 	});
 	result.outcomes.port = {
@@ -163,7 +170,65 @@ async function runStop(options) {
 	result.summary = summarize(root, result.outcomes, result.ok);
 	return result;
 }
-async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+async function stopBrowserOnly({ root, project = void 0, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), report = (line) => console.error(line) }) {
+	const kept = "Only the owned Chrome stops; the workspace server and devices keep running.";
+	const port = (project === void 0 ? getProject(root) : project)?.metroPort ?? null;
+	const outcomes = {
+		supervisor: {
+			status: "skipped",
+			reason: kept
+		},
+		collectors: {
+			status: "skipped",
+			entries: []
+		},
+		metro: {
+			status: "skipped",
+			reason: kept
+		},
+		device: {
+			ios: null,
+			android: null
+		},
+		port: port === null ? {
+			status: "none",
+			port
+		} : {
+			status: "kept",
+			port,
+			reason: kept
+		},
+		metroTunnel: { status: "none" },
+		releasedLeases: []
+	};
+	outcomes.device.web = await closeBrowser(root, teardownBrowser, report);
+	if (!outcomes.device.web) return {
+		ok: true,
+		outcomes,
+		summary: `Stopped: no owned Chrome was running (${root})`
+	};
+	const ok = outcomes.device.web.status === "shut-down";
+	return {
+		ok,
+		outcomes,
+		summary: summarize(root, outcomes, ok)
+	};
+}
+async function stopWorkspaceMacos(root, failed, enabled) {
+	if (enabled === false || readWorkspaceState(root)?.macos === void 0) return void 0;
+	try {
+		await stopMacosApp(root);
+		return { status: "stopped" };
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		failed(reason);
+		return {
+			status: "failed",
+			reason
+		};
+	}
+}
+async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, teardownBrowser = (projectRoot) => teardownOwnedBrowser(projectRoot), stopMacos, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
 	const proj = project === void 0 ? getProject(root) : project;
 	const sup = state === void 0 ? readSupervisorState(root) : state;
 	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
@@ -202,6 +267,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	});
 	if (target.status === "none") report(chalk.dim(phaseLine("stop", "no supervisor recorded")));
 	else if (target.status === "stale") {
+		logVanishedSupervisor(root, sup);
 		outcomes.supervisor = {
 			status: "already-stopped",
 			pid: target.pid,
@@ -219,6 +285,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 		stillHolding = `supervisor pid ${target.pid} could not be verified`;
 	} else {
 		outcomes.supervisor = await stopSupervisor(target, {
+			root,
 			killGroup,
 			waiter,
 			report
@@ -318,6 +385,10 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	}
 	outcomes.device.web = await closeBrowser(root, teardownBrowser, report);
 	if (outcomes.device.web && outcomes.device.web.status !== "shut-down") ok = false;
+	outcomes.macos = await stopWorkspaceMacos(root, (reason) => {
+		ok = false;
+		report(reason);
+	}, stopMacos);
 	const remote = remoteDevice === void 0 ? readRemoteSession(root) : remoteDevice;
 	const sessionId = typeof remote?.sessionId === "string" ? remote.sessionId : null;
 	if (sessionId) {
@@ -470,8 +541,9 @@ async function reapCollectors(root, collectors, { isAlive, signal, report, verif
 		entries
 	};
 }
-async function stopSupervisor(target, { killGroup, waiter, report }) {
+async function stopSupervisor(target, { root, killGroup, waiter, report }) {
 	report(chalk.dim(phaseLine("stop", `sending SIGTERM to supervisor process group ${target.pid}`)));
+	requestDevServerStop(root, target.processToken, { by: "stim stop" });
 	let signalled = false;
 	try {
 		signalled = killGroup(target.pid, target.processToken);
@@ -480,6 +552,7 @@ async function stopSupervisor(target, { killGroup, waiter, report }) {
 		report(chalk.red(phaseLine("stop", `could not signal supervisor pid ${target.pid}: ${String(e?.message || e)}`)));
 	}
 	if (!signalled) {
+		withdrawDevServerStopRequest(root, target.processToken);
 		const reason = `could not signal supervisor pid ${target.pid}`;
 		report(chalk.red(phaseLine("stop", reason)));
 		return {
@@ -691,6 +764,8 @@ async function closeBrowser(root, teardownBrowser, report) {
 }
 function summarize(root, outcomes, ok) {
 	const parts = [];
+	if (outcomes.macos?.status === "stopped") parts.push("macOS app stopped");
+	if (outcomes.macos?.status === "failed") parts.push("macOS app could not be stopped");
 	if (outcomes.supervisor.status === "stopped") parts.push(`supervisor pid ${outcomes.supervisor.pid} stopped`);
 	if (outcomes.supervisor.status === "already-stopped") parts.push("supervisor already stopped");
 	if (outcomes.supervisor.status === "timeout") parts.push(`supervisor pid ${outcomes.supervisor.pid} still running`);
@@ -752,6 +827,17 @@ function ownerGoneRefusal(holder, at) {
 		remedy: `Wait for the build tool${child} to exit, or end it yourself, then run \`stim stop\` again.`
 	});
 }
+function recordedDeviceSlots(root) {
+	const slots = new Set(projectDeviceSlots(getProject(root)).map(({ slot }) => slot));
+	for (const key of Object.keys({
+		...readCollectorState(root),
+		...fileLeaseIo.readHolder(root)
+	})) {
+		const parsed = parseDeviceSlotKey(key);
+		if (parsed) slots.add(parsed.slot);
+	}
+	return [...slots].toSorted();
+}
 function workspaceDeviceSlots(root) {
 	const slots = projectDeviceSlots(getProject(root)).filter(({ platforms }) => Object.values(platforms).some(Boolean)).map(({ slot }) => slot);
 	if (typeof readRemoteSession(root)?.sessionId === "string" && !slots.includes("default")) slots.push("default");
@@ -772,7 +858,21 @@ function readRemoteSessionEntry(root, report) {
 * SIGINT and given INTERRUPT_WAIT_MS to exit; a build for another slot that stays is left running while
 * the slot stops without the lock; any other holder is waited on with a visible notice.
 */
-async function stopWorkspaceNow({ root, slot, report = (line) => console.error(line), now = Date.now, sleep, waitMs = NATIVE_RUN_WAIT_MS, interruptWaitMs = INTERRUPT_WAIT_MS, inspectIdentity = process_identity_exports.inspectProcessIdentity, interrupt = (pid) => process.kill(pid, "SIGINT"), endRemote = (projectRoot) => readRemoteSessionEntry(projectRoot, report), deviceSlots = workspaceDeviceSlots, stop = (options) => runStop(options) }) {
+async function stopWorkspaceNow({ root, slot, report = (line) => console.error(line), now = Date.now, sleep, waitMs = NATIVE_RUN_WAIT_MS, interruptWaitMs = INTERRUPT_WAIT_MS, inspectIdentity = process_identity_exports.inspectProcessIdentity, interrupt = (pid) => process.kill(pid, "SIGINT"), endRemote = (projectRoot) => readRemoteSessionEntry(projectRoot, report), deviceSlots = workspaceDeviceSlots, recordedSlots = recordedDeviceSlots, stop = (options) => runStop(options) }) {
+	if (slot === "web") return stop({
+		root,
+		slot
+	});
+	let unknownSlot = slot !== void 0 && !recordedSlots(root).includes(slot);
+	const stillUnknown = () => {
+		const known = recordedSlots(root);
+		if (known.includes(slot)) return null;
+		return new StopBlocked({
+			code: "STIM_BAD_ARG",
+			message: `This workspace has no device slot named ${slot}. Its slots are ${known.join(", ")}.`,
+			remedy: `Run \`stim stop --slot <name>\` with one of those slots, \`stim stop --slot web\` to close only the owned Chrome, or \`stim stop\` for the whole workspace.`
+		});
+	};
 	let remote = null;
 	let remoteHandled = slot !== void 0;
 	const endRemoteNow = () => {
@@ -802,6 +902,11 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 		}
 		endRemoteNow();
 		const target = nativeRunHolder(holder);
+		if (unknownSlot) {
+			const refusal = target.slot === slot ? null : stillUnknown();
+			if (refusal) throw refusal;
+			unknownSlot = false;
+		}
 		const { action } = decideStopAction({
 			stopSlot: slot,
 			holder: target,
@@ -845,10 +950,14 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 		return result;
 	};
 	try {
-		return withRemote(await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, () => stop({
-			root,
-			slot
-		}), {
+		return withRemote(await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, () => {
+			const refusal = unknownSlot ? stillUnknown() : null;
+			if (refusal) throw refusal;
+			return stop({
+				root,
+				slot
+			});
+		}, {
 			external: true,
 			waitMs,
 			now,
@@ -875,7 +984,7 @@ async function stopWorkspaceNow({ root, slot, report = (line) => console.error(l
 	}
 }
 function stopCommand(program) {
-	program.command("stop").description("The inverse of `start`: halt this workspace's supervisor, shut the owned device down (never deleted), and free the reserved port. Non-destructive -- the device stays assigned, so coming back costs a boot. Acts on the current workspace.").option("--slot <name>", "Stop only this device slot, keeping the shared server running. Use 'default' for the workspace's default device.", parseDeviceSlotOption).option("--json", "print the per-step outcomes as JSON").action(async (opts) => {
+	program.command("stop").description("The inverse of `start`: halt this workspace's supervisor, shut the owned device down (never deleted), and free the reserved port. Non-destructive -- the device stays assigned, so coming back costs a boot. Acts on the current workspace.").option("--slot <name>", "Stop only this device slot, keeping the shared server running. Use 'default' for the workspace's default device, or 'web' to close only the owned Chrome.", (slot) => slot === "web" ? slot : parseDeviceSlotOption(slot)).option("--json", "print the per-step outcomes as JSON").action(async (opts) => {
 		const root = findCommandWorkspace(process.cwd());
 		if (!root) {
 			refuseNoProject({ json: Boolean(opts.json) });