stim 1.13.0 → 1.15.0

package/dist/macos-BwtbUtTN.mjs

@@ -0,0 +1,468 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { E as upsertProject, u as getConcurrencyLimits } from "./config-D0DbpZtM.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { C as workspaceLogsDir, b as workspaceDir, c as writeWorkspaceState, i as recordWorkspaceUse, p as ensureWorkspaceStorage } from "./workspace-state-CL2V2Ons.mjs";
+import { s as gitCommonDir, y as repoRoot } from "./worktree-C0c5Udwa.mjs";
+import { a as findProjectRoot$1 } from "./project-CV3tDFHl.mjs";
+import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { L as settingShapeErrors, N as resolveSettings, a as SETTING_SHAPE_REMEDY } from "./settings-CduVcoxj.mjs";
+import { a as requiredMacosRecord, n as macosLogFile, r as macosProcess, t as macosDir } from "./state-BxCgeTQu.mjs";
+import { r as releaseBuildSlot, t as acquireBuildSlot } from "./build-slots-Df1ApSuH.mjs";
+import { t as logLines } from "./run-B-xqRrsg.mjs";
+import { i as macosToolchain } from "./toolchain-DmeYjXD9.mjs";
+import { a as offloadBuild, c as placementLoad, d as OffloadRefusal, f as namedBuildMachine, i as closeOffload, l as remotePhaseText, m as resolveBuildPlacement, n as buildPlacementCandidates, p as parseBuildMachineOption, r as chooseBuildMachine, s as offloadPlacement } from "./client-C2IS36Qf.mjs";
+import { n as placeHostedMacos, t as connectHost } from "./hosted-macos-DwowNU7W.mjs";
+import { n as stopMacosAppHeld } from "./stop-Bvf1MflS.mjs";
+import { t as spawnEntry } from "./spawn-entry-DncpJvWL.mjs";
+import { n as stageBundle, r as validateInfoPlist, t as resolveBundleExtras } from "./stage-CzaiwFsI.mjs";
+import { d as withNativeBuildRun } from "./native-run-DFDoIRbY.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, existsSync, mkdirSync, mkdtempSync, openSync, realpathSync, renameSync, rmSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { machineCapacity, readMacosRecord, validHostedAppArguments } from "@stim-cli/core/state";
+//#region src/macos/build.ts
+async function tool(root, args, writer, note, capture = false) {
+	const child = spawnDeclared(() => getExecutor().spawn("swift", args, {
+		cwd: root,
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	}));
+	let stdout = "";
+	child.stdout?.on("data", (chunk) => {
+		if (capture) stdout += chunk.toString("utf8");
+	});
+	const write = (msg) => {
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "debug",
+			msg
+		});
+		note(msg);
+	};
+	if (child.stdout) logLines(child.stdout, write);
+	if (child.stderr) logLines(child.stderr, write);
+	await new Promise((done, reject) => {
+		child.once("error", reject);
+		child.once("close", (code) => code === 0 ? done() : reject(/* @__PURE__ */ new Error(`swift ${args[0]} failed (${code}). See stim logs --source build.`)));
+	});
+	return stdout.trim();
+}
+async function buildMacosBundle({ root, product, infoPlist, bundle, bundleId, scratch, writer, note, record, buildMachine, resources, assetCatalog }) {
+	if (record) record.buildMachine = buildMachine;
+	validateInfoPlist(root, product, infoPlist);
+	const repository = realpathSync(repoRoot(root) ?? root);
+	const extras = resolveBundleExtras(root, repository, resources, assetCatalog);
+	const write = (msg) => {
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "info",
+			msg
+		});
+		note(msg);
+	};
+	let offloadFallback = null;
+	const fallBack = (reason) => {
+		if (namedBuildMachine(buildMachine)) throw new OffloadRefusal(buildMachine, reason);
+		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})`);
+	};
+	mkdirSync(macosDir(root), { recursive: true });
+	const staging = mkdtempSync(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;
+	try {
+		try {
+			const { mode, machines } = buildPlacementCandidates(buildMachine);
+			const here = machineCapacity();
+			const placement = offloadPlacement({
+				mode,
+				machines: machines.length,
+				here,
+				unsupported: null,
+				selected: buildMachine
+			});
+			if (placement.offload) {
+				const chosen = await chooseBuildMachine({
+					projectRoot: root,
+					target: {
+						platform: "macos",
+						local: macosToolchain()
+					},
+					mode,
+					here,
+					machines,
+					selected: buildMachine,
+					note: (line) => write(`offload: ${line}`)
+				});
+				if (typeof chosen === "string") throw new Error(chosen);
+				choice = chosen;
+				write(`placement: ${choice.machine} (${placement.reason}${placementLoad(choice)})`);
+				const outcome = await offloadBuild({
+					choice,
+					request: {
+						platform: "macos",
+						product,
+						infoPlist: relative(root, resolve(root, infoPlist)),
+						bundleId,
+						resources: Object.fromEntries(Object.entries(extras.resources).map(([destination, source]) => [destination, relative(repository, source)])),
+						assetCatalog: extras.assetCatalog ? relative(repository, extras.assetCatalog) : null
+					},
+					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;
+					},
+					onRecord: (entry) => writer.write({
+						...entry,
+						offloadedTo: choice.machine
+					}),
+					note: write
+				});
+				if (!outcome.ok) throw new Error(`${outcome.machine}: ${outcome.reason}`);
+				const executable = join(outcome.artifactPath, "Contents", "MacOS", product);
+				const plist = JSON.parse(getExecutor().runFile("plutil", [
+					"-convert",
+					"json",
+					"-o",
+					"-",
+					join(outcome.artifactPath, "Contents", "Info.plist")
+				]));
+				if (plist.CFBundleIdentifier !== bundleId || plist.CFBundleExecutable !== product || !existsSync(executable)) throw new Error("The fetched macOS bundle does not match the requested identity and executable.");
+				for (const destination of [...Object.keys(extras.resources), ...extras.assetCatalog ? ["Assets.car"] : []]) if (!existsSync(join(outcome.artifactPath, "Contents", "Resources", destination))) throw new Error(`The fetched macOS bundle lacks declared resource ${destination}.`);
+				getExecutor().runFile("codesign", [
+					"--verify",
+					"--strict",
+					outcome.artifactPath
+				]);
+				promote(outcome.artifactPath);
+				if (record) {
+					record.offloadedTo = outcome.machine;
+					record.builtOn = outcome.machine;
+				}
+				return {
+					bundleId,
+					offloadedTo: outcome.machine,
+					offloadFallback: null,
+					handoff: outcome.handoff ?? null
+				};
+			}
+			write(`placement: here (${placement.reason})`);
+		} catch (error) {
+			fallBack(error instanceof Error ? error.message : String(error));
+		} finally {
+			if (choice) closeOffload(choice);
+		}
+		let slot;
+		try {
+			slot = await acquireBuildSlot({
+				max: getConcurrencyLimits().maxBuilds,
+				root,
+				logFile: writer.file,
+				out: note
+			});
+			if (record) record.builtOn = "here";
+			await tool(root, [
+				"build",
+				"-c",
+				"debug",
+				"--product",
+				product,
+				"--scratch-path",
+				scratch,
+				"--jobs",
+				"2"
+			], writer, note);
+			const bin = await tool(root, [
+				"build",
+				"-c",
+				"debug",
+				"--scratch-path",
+				scratch,
+				"--show-bin-path"
+			], writer, () => {}, true);
+			const staged = join(staging, `${product}.app`);
+			stageBundle(root, product, infoPlist, bin, staged, bundleId, extras);
+			promote(staged);
+			return {
+				bundleId,
+				offloadedTo: null,
+				offloadFallback,
+				handoff: null
+			};
+		} finally {
+			releaseBuildSlot(slot);
+		}
+	} finally {
+		try {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+//#endregion
+//#region src/commands/macos.ts
+/**
+* Builds the Debug app and launches it here, or with `remote` on that approved hosting Mac. A named host never falls
+* back to a local launch.
+*/
+async function runMacos(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 hosting Mac name from hosting.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 hosting.machines."), { code: "STIM_BAD_ARG" });
+	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 = resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root)
+	});
+	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 = 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" });
+	ensureWorkspaceStorage(root);
+	return withNativeBuildRun(root, {
+		command: "macos",
+		platform: "macos"
+	}, async () => {
+		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);
+			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(root, macos.infoPlist, record, remote !== void 0, note, macos);
+			if (!remote) return launchHere(root, record);
+			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 });
+				return placed;
+			} catch (error) {
+				write({
+					supervisor: void 0,
+					...placement ? {
+						host: placement,
+						hostLaunched: false
+					} : {}
+				});
+				throw error;
+			} finally {
+				connection.connection.close();
+			}
+		}, {
+			external: true,
+			declareSpawns: true,
+			ownerPurpose: "build and launch macOS app"
+		});
+	}, { write: note });
+}
+async function buildBundle(root, infoPlist, record, hosted, note, extras) {
+	const started = Date.parse(record.build.startedAt);
+	const scratch = join(macosDir(root), "build");
+	writeWorkspaceState(root, { macos: record });
+	const writer = createNdjsonWriter(macosLogFile(root), { maxBytes: LOG_ROTATE_BYTES });
+	try {
+		const { bundleId: base } = validateInfoPlist(root, record.product, infoPlist);
+		const bundleId = hosted ? base : `${base}.stim.${createHash("sha256").update(root).digest("hex").slice(0, 12)}`;
+		const built = await buildMacosBundle({
+			root,
+			product: record.product,
+			infoPlist,
+			bundle: record.bundle,
+			bundleId,
+			scratch,
+			writer,
+			note,
+			record: record.build,
+			buildMachine: record.build.buildMachine,
+			resources: extras.resources,
+			assetCatalog: extras.assetCatalog
+		});
+		record.bundleId = built.bundleId;
+		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 });
+		return built.handoff;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "error",
+			msg: message
+		});
+		writeWorkspaceState(root, { macos: {
+			...record,
+			supervisor: void 0,
+			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 } : {}
+			}
+		} });
+		throw error;
+	} finally {
+		writer.close();
+	}
+}
+async function launchHere(root, record) {
+	const fd = openSync(join(workspaceLogsDir(root), "macos-supervisor.log"), "a");
+	let child;
+	try {
+		child = spawnDeclared(() => getExecutor().spawn(process.execPath, [
+			spawnEntry("macos-run"),
+			root,
+			record.launchId
+		], {
+			cwd: root,
+			detached: true,
+			stdio: [
+				"ignore",
+				fd,
+				fd
+			],
+			env: {
+				...process.env,
+				STIM_BACKGROUND_LAUNCH: "1"
+			}
+		}));
+		child.unref();
+	} finally {
+		closeSync(fd);
+	}
+	const deadline = Date.now() + 2e4;
+	while (Date.now() < deadline) {
+		const current = readMacosRecord(root);
+		if (current?.launchId === record.launchId && current.app && current.supervisor && (0, process_identity_exports.inspectProcessIdentity)(current.app) === "same" && (0, process_identity_exports.inspectProcessIdentity)(current.supervisor) === "same") return current;
+		if (child.exitCode !== null || child.signalCode !== null) break;
+		await new Promise((done) => setTimeout(done, 100));
+	}
+	throw new Error("The macOS app did not register. See macos-supervisor.log in the workspace logs.");
+}
+function launchPayload(record) {
+	if (!record.host) return {
+		platform: "macos",
+		...record
+	};
+	const { product, launchId, build, host } = record;
+	return {
+		platform: "macos",
+		product,
+		launchId,
+		build,
+		host
+	};
+}
+function macosCommand(program) {
+	program.command("macos").description("Build and launch an owned Swift Package macOS Debug app.").option("--build-machine <value>", "Build on auto, local, or one named machine; a name refuses without fallback", parseBuildMachineOption).option("--json", "print one launch payload; build output goes to stderr").option("--remote <machine>", "run it on this approved hosting Mac from hosting.machines").action(async (options) => {
+		const root = findProjectRoot$1(process.cwd());
+		if (!root) throw new Error("Run stim macos from the Swift Package directory.");
+		const record = await runMacos(root, console.error, options.remote, options.buildMachine).catch((error) => {
+			const remedy = error.remedy;
+			if (typeof remedy === "string") console.error(`remedy: ${remedy}`);
+			throw error;
+		});
+		if (options.json) console.log(JSON.stringify(launchPayload(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}).`);
+	});
+}
+//#endregion
+export { macosCommand as default, runMacos };

package/dist/macos-run.d.mts

@@ -0,0 +1,5 @@
+//#region src/macos/run.d.ts
+declare function logLines(stream: NodeJS.ReadableStream, write: (line: string) => void): void;
+declare function runMacosSupervisor(root: string, launchId: string): Promise<void>;
+//#endregion
+export { logLines, runMacosSupervisor };

package/dist/macos-run.mjs

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

package/dist/{merge-state-ytFQCeh4.mjs → merge-state-BnxLNQiM.mjs}

@@ -1,10 +1,11 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { statSync } from "node:fs";
 //#region src/workspace/merge-state.ts
 const FETCH_TIMEOUT_MS = 3e4;
 const FETCH_FRESH_MS = 6e5;
 const GIT_TIMEOUT_MS = 6e4;
 const REMOTE_PREFIX = "refs/remotes/origin/";
+const MAX_MERGE_STATE_COMMITS = 2e3;
 function failure(error) {
 	const { stderr, message } = error;
 	const text = String(stderr ?? "").trim() || String(message ?? error);
@@ -130,7 +131,7 @@ function committedOn(path, branch, head) {
 * Anything git cannot answer is unknown, never merged. `coversUnpushed` is true for a patch-equivalent HEAD whose
 * upstream branch was deleted: its commits exist only locally, but their change is on the default branch.
 */
-function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS } = {}) {
+function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS, maxCommits = MAX_MERGE_STATE_COMMITS } = {}) {
 	const git = (args, input) => getExecutor().runFile("git", [
 		"--literal-pathspecs",
 		"-C",
@@ -140,13 +141,14 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS } = {}) {
 		timeoutMs,
 		input
 	});
-	const patch = (args) => getExecutor().runFile("git", [
+	const patch = (args, input) => getExecutor().runFile("git", [
 		"--literal-pathspecs",
 		"-C",
 		path,
 		...args
 	], {
 		timeoutMs,
+		input,
 		untrimmed: true
 	});
 	const patchIdCommits = (text) => new Map(text ? git(["patch-id", "--verbatim"], text).split("\n").flatMap((line) => {
@@ -156,11 +158,11 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS } = {}) {
 	const patchIds = (text) => [...patchIdCommits(text).keys()];
 	const committedAt = (commits) => {
 		const times = commits.length ? git([
-			"show",
-			"-s",
-			"--format=%ct",
-			...commits
-		]).split("\n").map(Number) : [];
+			"log",
+			"--no-walk",
+			"--stdin",
+			"--format=%ct"
+		], commits.join("\n")).split("\n").map(Number) : [];
 		if (!times.length || !times.every(Number.isFinite)) throw new Error(`no committer date for ${commits.join(" ")}`);
 		return Math.max(...times) * 1e3;
 	};
@@ -205,6 +207,16 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS } = {}) {
 				mergedAt: committedAt([landed])
 			};
 		}
+		const aheadCount = Number(git([
+			"rev-list",
+			"--count",
+			`${base}..${head}`
+		]));
+		if (aheadCount > maxCommits) return {
+			merged: false,
+			unknown: true,
+			detail: `merge state unknown: ${aheadCount} commits of its own ahead of the merge base with ${name} exceeds the ${maxCommits}-commit limit`
+		};
 		const files = git([
 			"diff",
 			"--name-only",
@@ -220,10 +232,8 @@ function mergeState(path, { ref, name }, { timeoutMs = GIT_TIMEOUT_MS } = {}) {
 			"--no-merges",
 			...diffOptions,
 			"--format=commit %H",
-			range,
-			"--",
-			...pathspec
-		]);
+			"--stdin"
+		], pathspec.length ? `${range}\n--\n${pathspec.join("\n")}\n` : `${range}\n`);
 		const upstream = patchIdCommits(log(`${base}..${ref}`, files));
 		const patchEquivalent = (ids) => ({
 			merged: true,