stim 1.20.1 → 1.21.0

package/dist/native-run-DY_RLx3C.mjs

@@ -0,0 +1,277 @@
+import { a as refuseDeclaredSpawns, f as ownership_claim_exports, l as isTermination, o as signalDeclaredSpawns, r as allowDeclaredSpawns, u as operationState } from "./exec-_UbtCQcG.mjs";
+import { d as workspaceDir } from "./paths-DQtTgsBf.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-B1UrjZHL.mjs";
+import { o as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-Cjuigeeu.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-1_1OoVW5.mjs";
+import { existsSync, mkdirSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+//#region src/cache/cache-claim.ts
+const LABEL = "cache";
+const POLL_MS = 500;
+const EMPTYING_WAIT_MS = 6e5;
+/**
+* The claim set guarding a cache Stim can only empty whole. It sits beside the cache's resolved directory, so emptying
+* the cache never removes it and every path that reaches the same cache names the same set; before the cache exists,
+* its resolved parent stands in for it.
+*/
+function cacheClaimRoot(dir) {
+	return `${existsSync(dir) ? canonicalPath(dir) : join(canonicalPath(dirname(dir)), basename(dir))}.claims`;
+}
+function describe(holder) {
+	const { platform, projectRoot } = holder.details;
+	const where = typeof projectRoot === "string" ? ` in ${projectRoot}` : "";
+	return holder.mode === "shared" ? `the ${typeof platform === "string" ? platform : "iOS"} build (pid ${holder.owner.pid}${where}) may be using it` : `pid ${holder.owner.pid} is emptying it`;
+}
+/** Why the cache at `dir` may be in use, from its claim set, without taking or removing any claim. */
+function cacheUser(dir) {
+	const root = cacheClaimRoot(dir);
+	const survey = (0, ownership_claim_exports.readClaimSet)(root);
+	const problem = survey.unresolved[0];
+	if (problem) return `the cache claim ${problem.path} is unresolved, so a build may be using it`;
+	const holder = survey.live[0];
+	return holder ? describe(holder) : void 0;
+}
+/**
+* Takes the exclusive claim an emptier holds while it removes the cache's contents; a string is why it cannot.
+* It never waits for a build that holds the cache.
+*/
+function claimForEmptying(dir) {
+	try {
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: cacheClaimRoot(dir),
+			mode: "exclusive",
+			label: LABEL
+		});
+		if (attempt.acquired) return attempt.acquired;
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		return holder ? describe(holder) : `its claim at ${cacheClaimRoot(dir)} could not be taken`;
+	} catch (error) {
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return error.message;
+		return `its claim at ${cacheClaimRoot(dir)} could not be taken: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+/**
+* Takes the shared claim a build holds on the compilation cache it compiles with, waiting while an emptier holds it.
+* A claim set Stim cannot resolve, or no process identity, is a failure: the build never runs unguarded.
+*/
+async function shareCompilationCache({ dir, projectRoot, note, signal }) {
+	const started = Date.now();
+	let told = false;
+	for (;;) {
+		signal?.throwIfAborted();
+		let attempt;
+		let root = `${dir}.claims`;
+		try {
+			mkdirSync(dirname(dir), { recursive: true });
+			root = cacheClaimRoot(dir);
+			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+				root,
+				mode: "shared",
+				label: LABEL,
+				details: {
+					platform: "ios",
+					projectRoot
+				}
+			});
+		} catch (error) {
+			return { failure: (0, ownership_claim_exports.claimFailure)(error, null) ?? {
+				code: ownership_claim_exports.CLAIM_UNAVAILABLE,
+				message: `Stim could not take the compilation cache claim at ${root}: ${error instanceof Error ? error.message : String(error)}.`,
+				remedy: `Restore write access to ${dirname(root)}, then retry the same Stim command.`
+			} };
+		}
+		if (attempt.acquired) return { claim: attempt.acquired };
+		const emptier = attempt.held ? `pid ${attempt.held.owner.pid}` : "another process";
+		const waited = Date.now() - started;
+		if (waited >= EMPTYING_WAIT_MS) return { failure: {
+			code: "STIM_BUILD_FAILED",
+			message: `${emptier} has been emptying the compilation cache at ${dir} for ${formatElapsed(waited)}.`,
+			remedy: "Run the same command again once it has finished."
+		} };
+		if (!told) note(phaseLine("build", `waiting for ${emptier} to finish emptying the compilation cache at ${dir}`));
+		told = true;
+		await setTimeout(POLL_MS);
+	}
+}
+//#endregion
+//#region src/engine/native-run.ts
+const NATIVE_RUN_LOCK = "native-run";
+const NATIVE_RUN_WAIT_MS = 18e5;
+const WAIT_HEARTBEAT_MS = 3e4;
+const CANCEL_REQUEST_KEY = "nativeRunCancel";
+const REQUEST_POLL_MS = 250;
+function nativeRunHolder(holder) {
+	const { command, platform, slot, interrupt } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default",
+		takesSignals: interrupt === "signal"
+	};
+}
+function describeNativeRunHolder(holder, now) {
+	const { command, slot } = nativeRunHolder(holder);
+	const started = Date.parse(holder.startedAt);
+	const facts = [`pid ${holder.owner.pid}`];
+	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
+	if (command === null) return `another Stim run (${facts.join(", ")})`;
+	if (command === "build") return `an artifact build (${facts.join(", ")})`;
+	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
+}
+/**
+* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
+* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
+*/
+function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
+	let claimId = null;
+	let lastAt = 0;
+	return (holder, firstLine) => {
+		const at = now();
+		if (holder.claimId !== claimId) {
+			claimId = holder.claimId;
+			lastAt = at;
+			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
+			return;
+		}
+		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
+		lastAt = at;
+		write(`still waiting for ${describe(holder, at)}`);
+	};
+}
+/**
+* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
+* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
+* stopped slot is the workspace's only device. A build for another slot that stays is left running and
+* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
+*/
+function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
+	if (holder.command === "macos" || holder.command === "build") {
+		if (stopSlot !== void 0) return { action: "proceed" };
+		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+	}
+	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
+	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
+	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+}
+const requestListeners = /* @__PURE__ */ new Map();
+/**
+* Ask the run holding `claimId` to cancel: the request is written to the workspace state, where the run's watch
+* finds it, and a run in this process is told at once.
+*/
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+	requestListeners.get(claimId)?.();
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState(root)?.[CANCEL_REQUEST_KEY];
+	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
+	return { pid: request.pid };
+}
+function clearNativeRunCancel(root, claimId) {
+	try {
+		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
+	} catch {}
+}
+/** The active native run of `context`'s operation aborts this signal when it is cancelled. */
+function runCancellationSignal(context) {
+	return operationState(context).runSignal;
+}
+/** Why `context`'s native run was cancelled, or null while it was not. */
+function runCancellation(context) {
+	return operationState(context).cancelled;
+}
+function cancelledFailure(context, platform, { code, message }) {
+	const cancelled = runCancellation(context);
+	if (cancelled === null) return null;
+	return {
+		code: "STIM_CANCELLED",
+		message: `The ${platform} run was ${cancelled} before it finished.`,
+		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
+		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
+	};
+}
+function cancelOnAbort({ context, root, claim, write, controller }) {
+	const state = operationState(context);
+	const cancel = () => {
+		if (controller.signal.aborted) return;
+		const request = cancelRequestFor(root, claim.claimId);
+		const cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		state.cancelled = cancelled;
+		state.handled = true;
+		controller.abort();
+		refuseDeclaredSpawns(context, `the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns(context, "SIGINT");
+		if (signalled > 0 || request) state.draining = true;
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+	};
+	const onAbort = () => {
+		if (!isTermination(context.signal.reason)) cancel();
+	};
+	const onRequest = () => {
+		if (controller.signal.aborted || !cancelRequestFor(root, claim.claimId)) return;
+		cancel();
+		state.abortOperation?.("stop");
+	};
+	context.signal.addEventListener("abort", onAbort);
+	if (context.signal.aborted) onAbort();
+	requestListeners.set(claim.claimId, onRequest);
+	const watch = setInterval(onRequest, REQUEST_POLL_MS);
+	watch.unref();
+	return () => {
+		clearInterval(watch);
+		requestListeners.delete(claim.claimId);
+		context.signal.removeEventListener("abort", onAbort);
+		allowDeclaredSpawns(context);
+		clearNativeRunCancel(root, claim.claimId);
+	};
+}
+/**
+* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
+* command, platform and slot, and a wait for another holder is reported on `write`. An abort of `context.signal`
+* forwards an interrupt to the running declared build tool and refuses any later one; a run `stim stop` cancelled
+* stops before its next build tool or install. A `SIGTERM` abort reason is left to the caller.
+*/
+function withNativeBuildRun(context, root, details, fn, { write }) {
+	const notice = nativeRunWaitNotice({ write });
+	const state = operationState(context);
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		state.cancelled = null;
+		const controller = new AbortController();
+		state.runSignal = controller.signal;
+		const dispose = cancelOnAbort({
+			context,
+			root,
+			claim,
+			write,
+			controller
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			dispose();
+			state.runSignal = void 0;
+		}
+	}, {
+		external: true,
+		signal: context.signal,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawnsFor: context,
+		details: {
+			...details,
+			interrupt: state.takesSignals ? "signal" : "request"
+		},
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
+export { decideStopAction as a, nativeRunWaitNotice as c, runCancellationSignal as d, withNativeBuildRun as f, shareCompilationCache as h, clearNativeRunCancel as i, requestNativeRunCancel as l, claimForEmptying as m, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cacheUser as p, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/{native-runtime-D024BAvm.mjs → native-runtime-Dg1Q7tfF.mjs}

@@ -1,15 +1,15 @@
-import { j as metroPortSetting } from "./settings-Bbztm4oV.mjs";
-import { p as ensureWorkspaceStorage, r as readWorkspaceState$1 } from "./workspace-state-CvgTFe-h.mjs";
-import { l as phaseLine } from "./command-output-CPDq_90S.mjs";
-import { u as resolveProjectMetro } from "./metro-_ZIE3Axg.mjs";
-import { c as startDevServer } from "./start-CRkG-mZ7.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-Dl78EVgR.mjs";
+import { n as ensureWorkspaceStorage } from "./paths-DQtTgsBf.mjs";
+import { l as phaseLine } from "./command-output-B1UrjZHL.mjs";
+import { r as readWorkspaceState$1 } from "./workspace-state-Cjuigeeu.mjs";
+import { j as metroPortSetting } from "./settings-CsJDEXgK.mjs";
+import { f as resolveProjectMetro } from "./metro-DEXpIhHC.mjs";
+import { Yt as LAUNCH_UNVERIFIED, qt as LAUNCH_BUNDLING } from "./budget-Bs6SxxzO.mjs";
+import { c as startDevServer } from "./start-7lpH7hmN.mjs";
 import { readIdleStop } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/native-runtime.ts
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function ensureDevServer({ root, port, settings, settingsContext, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
-	const pin = metroPortSetting(settings);
+async function ensureDevServer({ root, port, settings, settingsContext, remote, env, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
+	const pin = metroPortSetting(settings, env);
 	const canReuse = !pin.error && (pin.port === null || pin.port === port);
 	const held = port === null || !canReuse ? null : (await resolve(port, root)).metro;
 	if (port !== null && held) return {
@@ -77,4 +77,4 @@ function isPhysicalDeviceRequest(flag) {
 	return flag !== null && flag !== void 0 && flag !== false;
 }
 //#endregion
-export { sleep as a, launchOutcomeRecord as i, ensureWorkspaceStorageSafely as n, isPhysicalDeviceRequest as r, ensureDevServer as t };
+export { launchOutcomeRecord as i, ensureWorkspaceStorageSafely as n, isPhysicalDeviceRequest as r, ensureDevServer as t };

package/dist/{native-xcode-inputs-UElfGs59.mjs → native-xcode-inputs-CB2iQeWq.mjs}

@@ -1,10 +1,11 @@
-import { t as getExecutor } from "./exec-B81Qodjn.mjs";
-import { b as workspaceDerivedData, x as workspaceDir } from "./workspace-state-CvgTFe-h.mjs";
-import { m as pbxString, p as pbxReferences } from "./project-DX8fXyw_.mjs";
-import { f as NativeInputError, p as fingerprintNativeInputs } from "./native-gradle-inputs-BQnIdAlL.mjs";
+import { d as workspaceDir, u as workspaceDerivedData } from "./paths-DQtTgsBf.mjs";
+import { Gt as childEnvironment, qt as killOnAbort } from "./settings-CsJDEXgK.mjs";
+import { i as gitQuietAsync } from "./git-C3iTsJaZ.mjs";
+import { h as pbxString, m as pbxReferences } from "./project-BZNjmW_8.mjs";
+import { n as fingerprintNativeInputs, t as NativeInputError } from "./native-inputs-TRTTTRxt.mjs";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { createHash } from "node:crypto";
 //#region src/integrations/native-xcode-inputs.ts
 function nativeXcodePackages(root) {
 	return join(workspaceDir(root), "xcode-packages");
@@ -66,25 +67,30 @@ function inside(root, path) {
 function fold(path) {
 	return path.normalize("NFC").toLowerCase();
 }
-function gitVisibility(sourceRoot) {
+async function gitVisibility(sourceRoot, env, signal) {
+	signal?.throwIfAborted();
 	if (!existsSync(join(sourceRoot, ".git"))) return null;
-	const listing = getExecutor().runFileQuiet("git", [
-		"-C",
-		sourceRoot,
+	const childEnv = childEnvironment(env);
+	const listing = await gitQuietAsync(sourceRoot, [
 		"ls-files",
 		"-z",
 		"--cached",
 		"--others",
 		"--exclude-standard"
 	], {
+		env: childEnv.env,
 		untrimmed: true,
 		omitEnv: [
+			...childEnv.omitEnv,
 			"GIT_DIR",
 			"GIT_WORK_TREE",
 			"GIT_INDEX_FILE",
 			"GIT_COMMON_DIR"
-		]
+		],
+		timeoutMs: 12e4,
+		onSpawn: killOnAbort(signal)
 	});
+	signal?.throwIfAborted();
 	if (listing === null) return null;
 	const listed = /* @__PURE__ */ new Set();
 	const whole = /* @__PURE__ */ new Set();
@@ -106,9 +112,9 @@ function gitVisibility(sourceRoot) {
 		include
 	};
 }
-function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root) {
+async function nativeXcodeInputSnapshot(root, selection, parameters, env, sourceRoot = root, signal) {
 	if (selection.platform === "unknown") return { cacheIneligible: "The selected application platform cannot be resolved from its project configuration" };
-	const visibility = gitVisibility(sourceRoot);
+	const visibility = await gitVisibility(sourceRoot, env, signal);
 	const inputs = [{
 		name: "repository",
 		path: sourceRoot,
@@ -121,7 +127,7 @@ function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root
 	];
 	const reasons = /* @__PURE__ */ new Set();
 	const environment = {};
-	for (const [name, value] of Object.entries(process.env).toSorted(([a], [b]) => a.localeCompare(b))) if (value !== void 0 && /^(?:DEVELOPER_DIR|TOOLCHAINS|SDKROOT|CFLAGS|CPPFLAGS|CXXFLAGS|OBJCFLAGS|LDFLAGS|ARCHS|ONLY_ACTIVE_ARCH|SOURCE_DATE_EPOCH|ZERO_AR_DATE|IPHONEOS_DEPLOYMENT_TARGET|MACOSX_DEPLOYMENT_TARGET|DEVELOPMENT_TEAM|XCODE_.*|SWIFT_.*|CLANG_.*|GCC_.*|OTHER_.*FLAGS|CODE_SIGN.*|PROVISIONING_.*)$/.test(name)) environment[name] = value;
+	for (const [name, value] of Object.entries(env).toSorted(([a], [b]) => a.localeCompare(b))) if (value !== void 0 && /^(?:DEVELOPER_DIR|TOOLCHAINS|SDKROOT|CFLAGS|CPPFLAGS|CXXFLAGS|OBJCFLAGS|LDFLAGS|ARCHS|ONLY_ACTIVE_ARCH|SOURCE_DATE_EPOCH|ZERO_AR_DATE|IPHONEOS_DEPLOYMENT_TARGET|MACOSX_DEPLOYMENT_TARGET|DEVELOPMENT_TEAM|XCODE_.*|SWIFT_.*|CLANG_.*|GCC_.*|OTHER_.*FLAGS|CODE_SIGN.*|PROVISIONING_.*)$/.test(name)) environment[name] = value;
 	const dependencyRoots = /* @__PURE__ */ new Map();
 	const synchronizedRoots = [];
 	const reveal = (path, complete = true) => {
@@ -145,10 +151,10 @@ function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root
 		const result = value.replace(/\$\(([^)]+)\)|\$\{([^}]+)\}/g, (_match, parenthesized, braced) => {
 			const name = parenthesized ?? braced;
 			if (known[name] !== void 0) return known[name];
-			const env = process.env[name];
-			if (env !== void 0) {
-				environment[name] = env;
-				return env;
+			const supplied = env[name];
+			if (supplied !== void 0) {
+				environment[name] = supplied;
+				return supplied;
 			}
 			missing = true;
 			return "";
@@ -273,8 +279,8 @@ function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root
 			"CCC_OVERRIDE_OPTIONS",
 			"CLANG_CONFIG_FILE_USER_DIR",
 			"CLANG_CONFIG_FILE_SYSTEM_DIR"
-		]) if (process.env[name]) reasons.add(`Environment ${name} supplies native inputs outside the resolved project`);
-		if (process.env.XCODE_XCCONFIG_FILE) xcconfig(resolve(process.env.XCODE_XCCONFIG_FILE), selection.targetProject);
+		]) if (env[name]) reasons.add(`Environment ${name} supplies native inputs outside the resolved project`);
+		if (env.XCODE_XCCONFIG_FILE) xcconfig(resolve(selection.container.dir, env.XCODE_XCCONFIG_FILE), selection.targetProject);
 		for (const [name, value] of Object.entries(environment)) if (/(?:FLAGS|OTHER_.*FLAGS)$/.test(name) && /(?:[/@]|(?:^|\s)-(?:I|F|L|include|isystem|iquote|iframework|ivfsoverlay|fmodule|fplugin|resource-dir|sdk))/.test(value)) reasons.add(`Environment ${name} supplies compiler inputs outside the resolved project`);
 		if (nativeXcodeHasPackages(selection)) reasons.add("Swift package manifests, plugins and transitive local dependencies have no verified input closure");
 		if (reasons.size) return { cacheIneligible: [...reasons].join("; ") };
@@ -282,8 +288,9 @@ function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root
 			name,
 			path: realpathSync(path)
 		});
-		const snapshot = fingerprintNativeInputs(inputs, {
+		const snapshot = await fingerprintNativeInputs(inputs, {
 			excluded,
+			signal,
 			ignoredDirectoryMarkers: nativeXcodeMetadataDirectories(selection),
 			parameters: {
 				recipe: "native-xcode-v1",
@@ -299,6 +306,7 @@ function nativeXcodeInputSnapshot(root, selection, parameters, sourceRoot = root
 		if (snapshot.entries.some((entry) => synchronizedRoots.some((prefix) => entry.path.startsWith(`${prefix}/`)) && /\.(?:c|cc|cpp|cxx|m|mm|h|hh|hpp|hxx|metal)$/i.test(entry.path))) return { cacheIneligible: "C-family or Metal sources need a verified compiler include dependency graph" };
 		return snapshot;
 	} catch (error) {
+		signal?.throwIfAborted();
 		return { cacheIneligible: error instanceof NativeInputError ? error.message : `Native input closure is unavailable: ${error.message}` };
 	}
 }