stim 1.20.2 → 1.22.0

package/dist/macos-NfV2D7dO.mjs

@@ -0,0 +1,694 @@
+import { d as spawnDeclared, h as withDrainingCancellation, i as withWorkspaceProcessLock, t as getExecutor } from "./exec-DEoAhcze.mjs";
+import { d as workspaceDir, l as workspaceAgentDeviceDir, m as workspaceLogsDir$1, n as ensureWorkspaceStorage } from "./paths-DQtTgsBf.mjs";
+import { E as upsertProject, u as getConcurrencyLimits } from "./config-DlrsduwG.mjs";
+import { l as phaseLine } from "./command-output-gwpm28fu.mjs";
+import { f as throwIfCancelled } from "./operation-exec-BW0em61G.mjs";
+import { d as writeWorkspaceState, i as recordWorkspaceUse } from "./workspace-state-U08dEzhG.mjs";
+import { J as resolveProjectSettingsAsync, a as SETTING_SHAPE_REMEDY, et as settingShapeErrors } from "./settings-C7O8A6ZI.mjs";
+import { f as projectRegistry, i as findProjectRoot$1, s as ownedDeviceLabel } from "./project-wM_XFTvE.mjs";
+import { i as macosProcess, n as macosDir, o as requiredMacosRecord, r as macosLogFile } from "./state-08I3hw3_.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CgE_o3Dl.mjs";
+import { B as recordFinishedBuild, Fn as processContext, H as tapBuildLog, In as runProcessOperation, M as NO_BUILD_PROGRESS, V as startBuildProgress, z as recordBuildPhase } from "./budget-Cvwn54qV.mjs";
+import { d as runCancellationSignal, f as withNativeBuildRun } from "./native-run-NwUuxbkg.mjs";
+import { I as acquireBuildSlot, R as releaseBuildSlot } from "./workspaces-CpANmBlq.mjs";
+import { D as sanitizeDeviceLabel } from "./ios-hcBpnEGk.mjs";
+import { c as offloadPlacement, h as setRemoteLogSink, i as closeOffload, l as placementLoad, n as buildPlacementCandidates, o as offloadBuild, r as chooseBuildMachine, u as remotePhaseText } from "./client-OyRoEuSr.mjs";
+import { a as requireLocalBuild, i as parseBuildMachineOption, r as namedBuildMachine, s as resolveBuildPlacement, t as OffloadRefusal } from "./selection-DSMbWEX2.mjs";
+import { l as connectHost } from "./hosted-client-DZAPrcro.mjs";
+import { t as placeHostedMacos } from "./hosted-macos-_awYSpfv.mjs";
+import { r as stopMacosAppHeld, t as stopBundleInstances } from "./stop-Dky10AEJ.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { t as buildPlacementRecord } from "./placement-log-BnGgJRRZ.mjs";
+import { t as reidentifyBundle } from "./stage-Bps5oius.mjs";
+import { t as validateMacosArtifactPlatform } from "./artifact-platform-CXcmX_j3.mjs";
+import { t as waitForMacosRegistration } from "./registration-BcRgF6Ox.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, existsSync, openSync, promises, realpathSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { LOG_ROTATE_BYTES, ambientEnv } from "@stim-cli/core";
+import { machineCapacity, validHostedAppArguments } from "@stim-cli/core/state";
+//#region src/macos/build.ts
+async function buildMacosBundle({ context, root, recipe, bundle, bundleId, displayName, scratch, writer, note, record, buildMachine, progress = NO_BUILD_PROGRESS }) {
+	const signal = runCancellationSignal(context) ?? context.signal;
+	return withDrainingCancellation(context, signal, async () => {
+		throwIfCancelled(signal, "macOS build");
+		if (record) record.buildMachine = buildMachine;
+		setRemoteLogSink(context, (entry) => writer.write({
+			...entry,
+			platform: "macos"
+		}));
+		const write = (msg) => {
+			writer.write({
+				src: "build",
+				platform: "macos",
+				level: "info",
+				msg
+			});
+			note(msg);
+		};
+		let offloadFallback = null;
+		let asked = [];
+		let failedMachine;
+		const fallBack = (reason) => {
+			writer.write(buildPlacementRecord({
+				platform: "macos",
+				buildMachine,
+				candidates: asked,
+				event: "placement_fallback",
+				fallback: {
+					code: failedMachine ? "offload-failed" : "no-remote-mac-took-it",
+					reason,
+					machine: failedMachine
+				}
+			}));
+			if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, reason);
+			requireLocalBuild(buildMachine);
+			offloadFallback = reason;
+			if (record) record.offloadFallback = reason;
+			writer.write({
+				src: "build",
+				platform: "macos",
+				level: "warn",
+				event: "offload_failed",
+				msg: reason
+			});
+			write(`${reason} -> building here`);
+			write(`placement: here (${reason})`);
+		};
+		await promises.mkdir(macosDir(root), { recursive: true });
+		const staging = await promises.mkdtemp(join(macosDir(root), "staging-"));
+		const promote = (path) => {
+			const backup = join(staging, "previous.app");
+			const previous = existsSync(bundle);
+			if (previous) renameSync(bundle, backup);
+			try {
+				renameSync(path, bundle);
+			} catch (error) {
+				if (previous) renameSync(backup, bundle);
+				throw error;
+			}
+		};
+		let choice = null;
+		let retainStaging = false;
+		let identity = null;
+		const save = async (path) => {
+			if (!recipe.cache || !identity) return;
+			try {
+				if ((await recipe.cache.identity()).hash !== identity.hash) {
+					if (record) {
+						delete record.fingerprint;
+						delete record.cacheKey;
+					}
+					write("macOS inputs changed during the build; installing without caching.");
+					return;
+				}
+				const directory = join(staging, "cache-store");
+				await promises.mkdir(directory);
+				await recipe.cache.store(identity.key, path, directory);
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
+				throwIfCancelled(signal, "macOS cache store");
+				write(`macOS cache store skipped: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		};
+		try {
+			if (record) record.cacheHit = false;
+			if (recipe.cache) try {
+				identity = await recipe.cache.identity();
+				if (record) {
+					record.fingerprint = identity.hash;
+					record.cacheKey = identity.key;
+				}
+				const hit = await recipe.cache.restore(identity.key, join(staging, "cache-read"));
+				if (hit && (await recipe.cache.identity()).hash === identity.hash) {
+					await reidentifyBundle(context, hit.bundle, bundleId, displayName);
+					await recipe.validateFetched(hit.bundle, bundleId, displayName);
+					throwIfCancelled(signal, "macOS cache restore");
+					promote(hit.bundle);
+					if (record) {
+						record.cacheHit = true;
+						record.cacheSource = hit.tier;
+					}
+					write(`macOS cache hit (${hit.tier})`);
+					return {
+						bundleId,
+						offloadedTo: null,
+						offloadFallback: null,
+						handoff: null
+					};
+				}
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
+				throwIfCancelled(signal, "macOS cache lookup");
+				write(`macOS cache lookup skipped: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			let cacheOnly = false;
+			try {
+				const { mode, machines, localEnabled } = buildPlacementCandidates(buildMachine);
+				const peer = recipe.cache?.peer?.() ?? null;
+				const request = {
+					...recipe.offload.request(bundleId),
+					...peer ? {
+						artifactInputs: peer.inputs,
+						cacheArtifact: peer.write
+					} : {}
+				};
+				const here = machineCapacity();
+				const placement = offloadPlacement({
+					mode,
+					localEnabled,
+					machines: machines.length,
+					here,
+					unsupported: null,
+					selected: buildMachine
+				});
+				cacheOnly = !placement.offload && placement.code === "this-mac-free" && peer !== null;
+				if (placement.offload || cacheOnly) {
+					const chosen = await chooseBuildMachine({
+						projectRoot: root,
+						target: await recipe.offload.target(),
+						mode,
+						here,
+						machines,
+						selected: buildMachine,
+						note: (line) => write(`offload: ${line}`),
+						onCandidates: (each) => asked = each,
+						cacheOnly,
+						...peer ? { swiftpmArtifact: request } : {}
+					});
+					if (typeof chosen === "string") throw new Error(chosen);
+					choice = chosen;
+					failedMachine = chosen.machine;
+					writer.write(buildPlacementRecord({
+						platform: "macos",
+						buildMachine,
+						candidates: asked,
+						chose: {
+							machine: chosen.machine,
+							reason: `${placement.reason}${placementLoad(chosen)}`
+						}
+					}));
+					write(`placement: ${choice.machine} (${placement.reason}${placementLoad(choice)})`);
+					const outcome = await offloadBuild({
+						choice,
+						request,
+						stagingDir: join(staging, "offload"),
+						onPhase: (phase, line) => note(remotePhaseText(phase, line, choice.machine)),
+						onEnter: (phase) => {
+							if (record && [
+								"compile",
+								"build",
+								"prebuild",
+								"pods"
+							].includes(phase)) record.builtOn = choice.machine;
+							progress.place({
+								host: choice.machine,
+								phase
+							});
+							progress.step(phase === "fetch" ? "install" : "compile");
+						},
+						onRecord: (entry) => writer.write({
+							...entry,
+							offloadedTo: choice.machine
+						}),
+						note: write
+					});
+					progress.place(null);
+					if (!outcome.ok) throw new Error(`${outcome.machine}: ${outcome.reason}`);
+					progress.step("install");
+					if (outcome.cacheHit) {
+						await reidentifyBundle(context, outcome.artifactPath, bundleId, displayName);
+						await validateMacosArtifactPlatform(context, outcome.artifactPath, recipe.product, signal);
+					}
+					await recipe.validateFetched(outcome.artifactPath, bundleId, displayName);
+					throwIfCancelled(signal, "macOS build");
+					promote(outcome.artifactPath);
+					if (record) {
+						delete record.fingerprint;
+						delete record.cacheKey;
+						record.offloadedTo = outcome.machine;
+						record.builtOn = outcome.machine;
+						record.cacheHit = outcome.cacheHit === true;
+						if (outcome.cacheHit) record.cacheSource = "peer";
+					}
+					return {
+						bundleId,
+						offloadedTo: outcome.machine,
+						offloadFallback: null,
+						handoff: outcome.handoff ?? null
+					};
+				}
+				writer.write(buildPlacementRecord({
+					platform: "macos",
+					buildMachine,
+					stays: {
+						code: placement.code,
+						reason: placement.reason
+					}
+				}));
+				write(`placement: here (${placement.reason})`);
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainStaging = true;
+					throw error;
+				}
+				throwIfCancelled(signal, "macOS build");
+				if (cacheOnly) write(`placement: here (no reusable peer artifact)`);
+				else fallBack(error instanceof Error ? error.message : String(error));
+			} finally {
+				if (choice) closeOffload(choice);
+			}
+			let slot;
+			try {
+				slot = await acquireBuildSlot({
+					signal,
+					automatic: buildMachine === "auto",
+					max: getConcurrencyLimits().maxBuilds,
+					root,
+					logFile: writer.file,
+					out: note,
+					waitingFor: (info) => progress.waitingFor(info, "build-slot")
+				});
+				requireLocalBuild(buildMachine);
+				if (record) record.builtOn = "here";
+				progress.step("compile");
+				const bin = await recipe.compile({
+					scratch,
+					writer,
+					note
+				});
+				progress.step("install");
+				const staged = join(staging, `${recipe.product}.app`);
+				await recipe.stage(bin, staged, bundleId, displayName);
+				throwIfCancelled(signal, "macOS build");
+				releaseBuildSlot(slot);
+				slot = void 0;
+				await save(staged);
+				promote(staged);
+				return {
+					bundleId,
+					offloadedTo: null,
+					offloadFallback,
+					handoff: null
+				};
+			} finally {
+				releaseBuildSlot(slot);
+			}
+		} finally {
+			try {
+				if (!retainStaging) await promises.rm(staging, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+		}
+	});
+}
+//#endregion
+//#region src/macos/app-name.ts
+const DOT = String.fromCodePoint(183);
+const ELLIPSIS = String.fromCodePoint(8230);
+const LABEL_MAX = 24;
+const PRODUCT_MAX = 40;
+function clip(text, max) {
+	const chars = [...text];
+	return chars.length <= max ? text : `${chars.slice(0, max - 1).join("")}${ELLIPSIS}`;
+}
+/** The visible app name for a run: `<product> <dot> <label>`, or just the product when the label is empty. */
+function macosAppName(product, label) {
+	const name = clip(product.replace(/[\p{Cc}/:\\]+/gu, " ").trim(), PRODUCT_MAX) || "App";
+	const suffix = clip(sanitizeDeviceLabel(label), LABEL_MAX);
+	return suffix ? `${name} ${DOT} ${suffix}` : name;
+}
+function workspaceAppName(root, product) {
+	return macosAppName(product, ownedDeviceLabel(root));
+}
+//#endregion
+//#region src/macos/plan.ts
+async function planMacos(context, root, buildMachineFlag) {
+	if (process.platform !== "darwin") throw new Error("stim macos requires a Mac with Swift installed.");
+	root = realpathSync(root);
+	if (!existsSync(join(root, "Package.swift"))) throw new Error("Run stim macos from the directory containing Package.swift.");
+	const { settings } = await resolveProjectSettingsAsync(root, {
+		env: context.env,
+		signal: context.signal
+	});
+	const [shape] = settingShapeErrors(settings);
+	if (shape) throw new Error(`${shape} ${SETTING_SHAPE_REMEDY}`);
+	const selected = resolveBuildPlacement(buildMachineFlag);
+	if (selected.failure) throw Object.assign(new Error(selected.failure.message), selected.failure);
+	const macos = settings.macos;
+	if (!macos?.product || !macos.infoPlist) throw Object.assign(/* @__PURE__ */ new Error("Set macos.product and macos.infoPlist explicitly in .stim.json. See stim guide macos."), { code: "STIM_BAD_ARG" });
+	const { swiftpmMacosProject } = await import("./swiftpm-macos-BIak-Rxv.mjs");
+	const recipe = await swiftpmMacosProject(root).prepare(context, settings);
+	let identity = null;
+	let cacheHit = false;
+	if (recipe.cache) try {
+		identity = await recipe.cache.identity();
+		cacheHit = await recipe.cache.has(identity.key);
+	} catch (error) {
+		if (error instanceof Error && "reportCleanup" in error) throw error;
+		context.signal.throwIfAborted();
+	}
+	return {
+		platform: "macos",
+		product: macos.product,
+		buildMachine: selected.selected,
+		fingerprint: identity?.hash ?? null,
+		cacheKey: identity?.key ?? null,
+		cacheHit,
+		provider: null,
+		cacheSkipped: identity === null,
+		prebuild: null,
+		outcome: null,
+		expectedMs: null,
+		basis: 0
+	};
+}
+//#endregion
+//#region src/commands/macos.ts
+/**
+* Builds the Debug app and launches it here, or with `remote` on that approved remote Mac. A named host never falls
+* back to a local launch.
+*/
+async function runMacos(context, root, note = console.error, remote, buildMachineFlag) {
+	const backend = remote?.trim().toLowerCase();
+	if (backend === "eas" || backend === "proxy") throw Object.assign(/* @__PURE__ */ new Error("stim macos --remote takes a remote Mac name from remote.machines; macOS has no eas or proxy backend."), { code: "STIM_BAD_ARG" });
+	if (backend === "auto") throw Object.assign(/* @__PURE__ */ new Error("stim macos --remote auto is not available yet: automatic placement has not shipped. Name a hosting Mac from remote.machines."), { code: "STIM_BAD_ARG" });
+	if (process.platform !== "darwin") throw new Error("stim macos requires a Mac with Swift installed.");
+	root = realpathSync(root);
+	const operation = projectRegistry.selectMacos(root);
+	if ("problem" in operation) throw Object.assign(new Error(operation.problem.message), {
+		code: "STIM_NO_PROJECT",
+		remedy: operation.problem.remedy
+	});
+	const { settings } = await resolveProjectSettingsAsync(root, {
+		env: context.env,
+		signal: runCancellationSignal(context) ?? context.signal
+	});
+	const [shape] = settingShapeErrors(settings);
+	if (shape) throw new Error(`${shape} ${SETTING_SHAPE_REMEDY}`);
+	const selected = resolveBuildPlacement(buildMachineFlag);
+	if (selected.failure) throw Object.assign(new Error(selected.failure.message), selected.failure);
+	const buildMachine = selected.selected;
+	const macos = await (await operation.load()).prepare(context, settings);
+	ensureWorkspaceStorage(root);
+	return withNativeBuildRun(context, root, {
+		command: "macos",
+		platform: "macos"
+	}, async (claim) => {
+		const progress = startBuildProgress({
+			root,
+			platform: "macos",
+			slot: "default",
+			claim,
+			note
+		});
+		return withWorkspaceProcessLock(workspaceDir(root), "macos-launch", async () => {
+			const previous = requiredMacosRecord(root);
+			if (previous?.host && previous.host.machine !== remote) throw new Error(`This workspace's macOS app runs on ${previous.host.machine}. Run stim stop first, then stim macos${remote ? ` --remote ${remote}` : ""}.`);
+			if (remote && !validHostedAppArguments(macos.arguments)) throw new Error("macos.arguments is too large for a hosted app: at most 32 arguments of 1024 characters (8192 in total), without NUL or line breaks.");
+			if (remote) (await connectHost(remote)).connection.close();
+			if (!previous?.host) await stopMacosAppHeld(root);
+			upsertProject(root, {});
+			recordWorkspaceUse(root, /* @__PURE__ */ new Date(), context.env, context.cwd);
+			const bundle = join(macosDir(root), `${macos.product}.app`);
+			const record = {
+				product: macos.product,
+				bundle,
+				bundleId: "",
+				executable: join(bundle, "Contents", "MacOS", macos.product),
+				launchId: randomUUID(),
+				arguments: macos.arguments,
+				supervisor: macosProcess(process.pid),
+				build: {
+					state: "running",
+					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					buildMachine
+				},
+				...previous?.host ? {
+					host: previous.host,
+					hostLaunched: previous.hostLaunched ?? false
+				} : {}
+			};
+			const handoff = await buildBundle(context, root, macos, record, remote !== void 0, note, progress);
+			progress.step("launch");
+			const launched = () => {
+				try {
+					recordBuildPhase(root, "macos", record.build.startedAt, "launch", progress.durations().launch ?? 0);
+				} catch (error) {
+					note(`The launch time could not be recorded in the build history: ${error?.message || error}`);
+				}
+			};
+			if (!remote) {
+				const here = await launchHere(context, root, record, note);
+				launched();
+				return here;
+			}
+			const connection = await connectHost(remote);
+			const write = (patch) => writeWorkspaceState(root, { macos: {
+				...record,
+				...patch
+			} });
+			let placement = record.host;
+			try {
+				const run = await placeHostedMacos(connection, {
+					root,
+					bundle: record.bundle,
+					bundleId: record.bundleId,
+					handoff,
+					arguments: macos.arguments,
+					recorded: previous?.host,
+					reserved: (reserved) => {
+						placement = reserved;
+						write({
+							host: reserved,
+							hostLaunched: false
+						});
+					},
+					note
+				});
+				const placed = {
+					...record,
+					supervisor: void 0,
+					arguments: run.arguments,
+					host: run.placement,
+					hostLaunched: run.launched
+				};
+				writeWorkspaceState(root, { macos: placed });
+				launched();
+				return placed;
+			} catch (error) {
+				write({
+					supervisor: void 0,
+					...placement ? {
+						host: placement,
+						hostLaunched: false
+					} : {}
+				});
+				throw error;
+			} finally {
+				connection.connection.close();
+			}
+		}, {
+			external: true,
+			declareSpawnsFor: context,
+			ownerPurpose: "build and launch macOS app"
+		}).finally(() => progress.clear());
+	}, { write: note });
+}
+async function buildBundle(context, root, recipe, record, hosted, note, progress = NO_BUILD_PROGRESS) {
+	const started = Date.parse(record.build.startedAt);
+	const scratch = join(macosDir(root), "build");
+	writeWorkspaceState(root, { macos: record });
+	const writer = tapBuildLog(createNdjsonWriter(macosLogFile(root), { maxBytes: LOG_ROTATE_BYTES }), progress);
+	try {
+		const base = recipe.bundleId;
+		const bundleId = hosted ? base : `${base}.stim.${createHash("sha256").update(root).digest("hex").slice(0, 12)}`;
+		const displayName = workspaceAppName(root, record.product);
+		const built = await buildMacosBundle({
+			context,
+			root,
+			recipe,
+			bundle: record.bundle,
+			bundleId,
+			displayName,
+			scratch,
+			writer,
+			note,
+			progress,
+			record: record.build,
+			buildMachine: record.build.buildMachine
+		});
+		record.bundleId = built.bundleId;
+		record.displayName = displayName;
+		record.bundle = realpathSync(record.bundle);
+		record.executable = realpathSync(join(record.bundle, "Contents", "MacOS", record.product));
+		record.build = {
+			...record.build,
+			state: "ok",
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: Date.now() - started
+		};
+		writeWorkspaceState(root, { macos: record });
+		recordMacosBuild(root, record.build, progress.steps());
+		return built.handoff;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "error",
+			msg: message
+		});
+		const build = {
+			...record.build,
+			state: "failed",
+			finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			durationMs: Date.now() - started,
+			error: message,
+			..."code" in Object(error) && typeof error.code === "string" ? { errorCode: error.code } : {}
+		};
+		writeWorkspaceState(root, { macos: {
+			...record,
+			supervisor: void 0,
+			build
+		} });
+		recordMacosBuild(root, build, progress.steps());
+		throw error;
+	} finally {
+		writer.close();
+	}
+}
+function recordMacosBuild(root, build, compileSteps) {
+	recordFinishedBuild(root, {
+		platform: "macos",
+		status: build.state === "ok" ? "ok" : "failed",
+		configuration: "Debug",
+		fingerprint: build.fingerprint ?? null,
+		cacheKey: build.cacheKey ?? null,
+		cacheHit: build.cacheHit ? build.cacheSource === "provider" ? "remote" : "local" : false,
+		cacheSkipped: !build.cacheKey,
+		durationMs: build.durationMs,
+		startedAt: build.startedAt,
+		errorCode: build.errorCode,
+		buildMachine: build.buildMachine,
+		builtOn: build.builtOn,
+		offloadedTo: build.offloadedTo,
+		offloadFallback: build.offloadFallback,
+		...compileSteps === null ? {} : { compileSteps }
+	});
+}
+const LAUNCH_SERVICES_CALL_MS = 2e3;
+async function waitForLaunchServices(record, deadline) {
+	if (record.host || !record.app) return "skipped";
+	const args = [
+		"find",
+		`bundleid=${record.bundleId}`,
+		`pid=${record.app.pid}`
+	];
+	while (Date.now() < deadline) {
+		if ((await getExecutor().runFileAsync("lsappinfo", args, { timeoutMs: LAUNCH_SERVICES_CALL_MS }).catch(() => "")).includes("ASN:")) return "listed";
+		await new Promise((done) => setTimeout(done, 100));
+	}
+	return "timeout";
+}
+async function launchHere(context, root, record, note) {
+	await stopBundleInstances(root);
+	const fd = openSync(join(workspaceLogsDir$1(root), "macos-supervisor.log"), "a");
+	let child;
+	try {
+		child = spawnDeclared(context, () => getExecutor().spawn(process.execPath, [
+			spawnEntry("macos-run"),
+			root,
+			record.launchId
+		], {
+			cwd: root,
+			detached: true,
+			stdio: [
+				"ignore",
+				fd,
+				fd,
+				"ipc"
+			],
+			env: {
+				...ambientEnv(),
+				STIM_BACKGROUND_LAUNCH: "1"
+			}
+		}));
+		child.unref();
+	} finally {
+		closeSync(fd);
+	}
+	const deadline = Date.now() + 2e4;
+	const current = await waitForMacosRegistration(root, record.launchId, child, deadline);
+	if (current) {
+		if (await waitForLaunchServices(current, deadline) === "timeout") note("macOS LaunchServices does not list the app yet. agent-device open may start a second copy; wait and check lsappinfo.");
+		return current;
+	}
+	throw new Error("The macOS app did not register. See macos-supervisor.log in the workspace logs.");
+}
+function launchPayload(root, record) {
+	const agentDevice = { stateDir: workspaceAgentDeviceDir(root) };
+	if (!record.host) return {
+		agentDevice,
+		platform: "macos",
+		...record
+	};
+	const { product, displayName, launchId, build, host } = record;
+	return {
+		agentDevice,
+		platform: "macos",
+		product,
+		displayName,
+		launchId,
+		build,
+		host
+	};
+}
+function macosCommand(program) {
+	program.command("macos").description("Build and launch an owned Swift Package macOS Debug app.").option("--remote-build <value>", "Build on auto, local, or one named machine; a name refuses without fallback", parseBuildMachineOption).option("--json", "print one launch or plan payload; build output goes to stderr").option("--plan", "validate the next SwiftPM Debug build without building or launching").option("--remote <machine>", "run it on this approved remote Mac from remote.machines").action(async (options) => {
+		const root = findProjectRoot$1(process.cwd());
+		if (options.plan) {
+			try {
+				if (!root) throw new Error("Run stim macos from the Swift Package directory.");
+				if (options.remote !== void 0) throw Object.assign(/* @__PURE__ */ new Error("--remote selects a launch host and does not apply to --plan."), { code: "STIM_BAD_ARG" });
+				const plan = await planMacos(processContext(root, new AbortController().signal), root, options.remoteBuild);
+				if (options.json) console.log(JSON.stringify(plan));
+				else {
+					console.log(phaseLine("plan", `macos ${plan.product}: SwiftPM Debug build, then stage and launch`));
+					console.log(phaseLine("build", `selection: ${plan.buildMachine}; worker availability is not checked`));
+					console.log(phaseLine("expect", "unknown: SwiftPM determines incremental work when the build runs"));
+				}
+			} catch (error) {
+				const failure = {
+					code: error.code ?? "STIM_BAD_ARG",
+					message: error instanceof Error ? error.message : String(error),
+					remedy: error.remedy ?? "Check the macOS project settings in stim guide macos."
+				};
+				console.error(failure.message);
+				if (options.json) console.log(JSON.stringify(failure));
+				process.exitCode = 1;
+			}
+			return;
+		}
+		if (!root) throw new Error("Run stim macos from the Swift Package directory.");
+		const { value: record } = await runProcessOperation(root, (context) => runMacos(context, root, console.error, options.remote, options.remoteBuild)).catch((error) => {
+			const remedy = error.remedy;
+			if (typeof remedy === "string") console.error(`remedy: ${remedy}`);
+			throw error;
+		});
+		if (options.json) console.log(JSON.stringify(launchPayload(root, record)));
+		else if (record.host) console.log(`Started ${record.product} on ${record.host.machine} as ${record.host.bundleId}${record.hostLaunched === true ? "" : " (launch not confirmed)"}.`);
+		else console.log(`Started ${record.product} (pid ${record.app?.pid}).`);
+		if (!options.json) console.log(phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`));
+	});
+}
+//#endregion
+export { buildMacosBundle as a, planMacos as i, runMacos as n, waitForLaunchServices as r, macosCommand as t };

package/dist/macos-run.mjs

@@ -1,2 +1,2 @@
-import { n as runMacosSupervisor, t as logLines } from "./run-BtPgpKks.mjs";
+import { n as runMacosSupervisor, t as logLines } from "./run-DidHghD1.mjs";
 export { logLines, runMacosSupervisor };