stim 1.19.0 → 1.20.0

package/dist/{support-CNqYkV0y.mjs → support-DCco5fut.mjs}

@@ -1,15 +1,64 @@
-import { h as shortUdid, l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
-import { x as workspaceLogsDir } from "./workspace-state-CR9X86xJ.mjs";
-import { A as parseIosSimulatorApp } from "./ios-BWbHFZVz.mjs";
-import { d as unknownIosDeviceTypeRefusal, f as unknownIosRuntimeRefusal, o as layerNote, t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-BoN1jQkO.mjs";
-import { k as describeDiagnostic } from "./toolchain-C3xSoyUl.mjs";
-import { t as IosDeviceMismatchError } from "./device-ios-B2ruohE-.mjs";
-import { l as parseDeviceWait } from "./device-lease-run-D38SnZtt.mjs";
+import { Q as settingShapeErrors, a as SETTING_SHAPE_REMEDY, b as iosProjectDirSettingError, nt as unknownSettingKeys, p as cacheProviderSettingError, y as iosProjectDirSetting } from "./settings-Bbztm4oV.mjs";
+import { w as workspaceLogsDir } from "./workspace-state-CSIFuuDa.mjs";
+import { h as shortUdid, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { p as resolveOptimizations } from "./errors-DzkMYh8Q.mjs";
+import { y as resolveBuildPlacement } from "./client-BLy1Pw2V.mjs";
+import { j as parseIosSimulatorApp } from "./ios-CXLIUxXJ.mjs";
+import { F as describeDiagnostic } from "./toolchain-DqyDXs30.mjs";
+import { d as unknownIosDeviceTypeRefusal, f as unknownIosRuntimeRefusal, o as layerNote, t as DEFAULT_DEVICE_SLOT_WAIT_MS } from "./device-capacity-Ca_ke1LE.mjs";
+import { l as parseDeviceWait } from "./device-lease-run-CvDeHTkG.mjs";
+import { t as IosDeviceMismatchError } from "./device-ios-CRUqPxKw.mjs";
 import { basename, join } from "node:path";
 import chalk from "chalk";
 function buildLogFile(root) {
 	return join(workspaceLogsDir(root), `build-ios.ndjson`);
 }
+function iosProjectPathError(settings, root, isExpo) {
+	const error = iosProjectDirSettingError(settings, root);
+	if (error || !iosProjectDirSetting(settings, root).custom || !isExpo()) return error;
+	return "ios.projectPath applies to bare React Native apps only: expo prebuild generates and builds ios/. Remove it for this Expo app.";
+}
+function resolveIosBuildSetup(remoteBuild, settings, warn) {
+	const [shapeError, ...lines] = settingShapeErrors(settings);
+	if (shapeError) return {
+		ok: false,
+		failure: {
+			code: "STIM_BAD_ARG",
+			message: shapeError,
+			lines,
+			remedy: SETTING_SHAPE_REMEDY
+		}
+	};
+	const placement = resolveBuildPlacement(remoteBuild);
+	if (placement.failure) return {
+		ok: false,
+		failure: {
+			...placement.failure,
+			setup: true
+		}
+	};
+	let optimizations;
+	try {
+		optimizations = resolveOptimizations(settings);
+	} catch (error) {
+		return {
+			ok: false,
+			failure: {
+				code: "STIM_BAD_ARG",
+				message: error.message,
+				remedy: SETTING_SHAPE_REMEDY
+			}
+		};
+	}
+	for (const key of unknownSettingKeys(settings)) warn("setting", `Warning: setting "${key}" is not read by Stim and will be ignored.`);
+	const cacheProviderError = cacheProviderSettingError(settings);
+	if (cacheProviderError) warn("cache", `${cacheProviderError} Using the local cache.`);
+	return {
+		ok: true,
+		buildMachine: placement.selected,
+		optimizations
+	};
+}
 const MAX_PRINTED_DIAGNOSTICS = 6;
 function deviceLabel(device, udid) {
 	const name = device?.deviceName || device?.name || null;
@@ -32,6 +81,10 @@ function iosConfigurationSetting(settings) {
 function resolveConfiguration(flag, settings) {
 	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || iosConfigurationSetting(settings);
 }
+function resolveSchemeSelection({ scheme, easProfile }, settings) {
+	if (typeof scheme === "string" || easProfile !== void 0) return scheme ?? void 0;
+	return iosStringSetting(settings, "scheme") ?? void 0;
+}
 function iosStringSetting(settings, key) {
 	const ios = settings?.["ios"];
 	if (!ios || typeof ios !== "object" || Array.isArray(ios)) return null;
@@ -223,4 +276,4 @@ function createIosDeviceWaitRun(stats, progress, signal) {
 	};
 }
 //#endregion
-export { resolveSimulatorAppFlag as _, deviceModelRefusal as a, iosProviderRunOptions as c, podAction as d, printDiagnostics as f, resolveRuntime as g, resolveIosWait as h, deviceLabel as i, isReleaseConfiguration as l, resolveDeviceType as m, buildLogFile as n, deviceShortName as o, resolveConfiguration as p, createIosDeviceWaitRun as r, iosConfigurationSetting as s, appNameFromPath as t, ownedSimFailure as u, simulatorBuildArch as v, xcodeFailureReport as y };
+export { xcodeFailureReport as S, resolveIosWait as _, deviceModelRefusal as a, resolveSimulatorAppFlag as b, iosProjectPathError as c, ownedSimFailure as d, podAction as f, resolveIosBuildSetup as g, resolveDeviceType as h, deviceLabel as i, iosProviderRunOptions as l, resolveConfiguration as m, buildLogFile as n, deviceShortName as o, printDiagnostics as p, createIosDeviceWaitRun as r, iosConfigurationSetting as s, appNameFromPath as t, isReleaseConfiguration as u, resolveRuntime as v, simulatorBuildArch as x, resolveSchemeSelection as y };

package/dist/{swiftpm-macos-aJzPAj1t.mjs → swiftpm-macos-afeNUExW.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { mt as repoRoot } from "./settings-CxgngUZk.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { Et as repoRoot } from "./settings-Bbztm4oV.mjs";
 import { a as spawnDeclared } from "./spawn-claims-Kqiifsk2.mjs";
-import { i as macosToolchain } from "./toolchain-C3xSoyUl.mjs";
-import { i as validateInfoPlist, n as setBundleName, r as stageBundle, t as resolveBundleExtras } from "./stage-BgaZJVZY.mjs";
-import { t as logLines } from "./run-lAkle1-c.mjs";
+import { s as macosToolchain } from "./toolchain-DqyDXs30.mjs";
+import { i as validateInfoPlist, n as setBundleName, r as stageBundle, t as resolveBundleExtras } from "./stage-BNKKdDNc.mjs";
+import { t as logLines } from "./run-qvff78hv.mjs";
 import { existsSync, realpathSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 //#region src/integrations/swiftpm-macos.ts

package/dist/tailnet-CoJUb2tB.mjs

@@ -0,0 +1,265 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { a as formatElapsed } from "./command-output-BjPN99ZB.mjs";
+import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-Kqiifsk2.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-C2lvoPsb.mjs";
+import { endpoint, findPeer as findPeer$1, isJsonObject, parseMachine, parseMachine as parseMachine$1, pinnedEndpoint } from "@stim-cli/core/state";
+import { WebSocket } from "ws";
+//#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";
+function nativeRunHolder(holder) {
+	const { command, platform, slot } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default"
+	};
+}
+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" };
+}
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState$1(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 {}
+}
+let cancelled = null;
+let cancellationSignal;
+/** The active native run aborts this signal when it is cancelled. */
+function runCancellationSignal() {
+	return cancellationSignal;
+}
+/** Why this process's native run was cancelled, or null while it was not. */
+function runCancellation() {
+	return cancelled;
+}
+function cancelledFailure(platform, { code, message }) {
+	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 cancelOnInterrupt({ root, claim, write, exit, controller }) {
+	let signals = 0;
+	const onInterrupt = () => {
+		signals += 1;
+		if (signals > 1) {
+			exit(130);
+			return;
+		}
+		const request = cancelRequestFor(root, claim.claimId);
+		cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		controller.abort();
+		refuseDeclaredSpawns(`the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns("SIGINT");
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+		if (signalled === 0 && !request) exit(130);
+	};
+	process.on("SIGINT", onInterrupt);
+	return () => {
+		process.off("SIGINT", onInterrupt);
+		allowDeclaredSpawns();
+		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`. The first SIGINT
+* forwards the interrupt to the running declared build tool; a run `stim stop` cancelled between build
+* tools starts no further one; a terminal interrupt with no build tool running, or a second SIGINT, exits
+* with 130 at once.
+*/
+function withNativeBuildRun(root, details, fn, { write, exit = (code) => process.exit(code) }) {
+	const notice = nativeRunWaitNotice({ write });
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		cancelled = null;
+		const controller = new AbortController();
+		cancellationSignal = controller.signal;
+		const dispose = cancelOnInterrupt({
+			root,
+			claim,
+			write,
+			exit,
+			controller
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			dispose();
+			cancellationSignal = void 0;
+		}
+	}, {
+		external: true,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawns: true,
+		details: { ...details },
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
+//#region src/offload/tailnet.ts
+const MAC_APP_TAILSCALE = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+const HELLO_TIMEOUT_MS = 1e4;
+function isLapsed(credential) {
+	return credential.state === "pending" && !!credential.expiresAt && Date.parse(credential.expiresAt) <= Date.now();
+}
+function markApproved(credential) {
+	const { expiresAt: _expiresAt, ...rest } = credential;
+	return {
+		...rest,
+		state: "approved"
+	};
+}
+function pendingReport(credential) {
+	return {
+		state: "pending",
+		...credential.expiresAt ? { expiresAt: credential.expiresAt } : {}
+	};
+}
+function lapsedLine(machine, credential) {
+	return `${machine} did not approve this Mac before the request lapsed at ${credential.expiresAt}.`;
+}
+function requestedLine(credential) {
+	return `Requested at ${credential.requestedAt}${credential.expiresAt ? `; the request lapses at ${credential.expiresAt}` : ""}.`;
+}
+function parseTailscaleStatus(output) {
+	try {
+		const status = JSON.parse(output);
+		return isJsonObject(status) && status.BackendState === "Running" ? status : null;
+	} catch {
+		return null;
+	}
+}
+function tailscaleStatus() {
+	for (const binary of ["tailscale", MAC_APP_TAILSCALE]) {
+		const output = getExecutor().runFileQuiet(binary, ["status", "--json"], { timeoutMs: 5e3 });
+		if (output !== null) return parseTailscaleStatus(output);
+	}
+	return null;
+}
+async function tailscaleStatusAsync() {
+	for (const binary of ["tailscale", MAC_APP_TAILSCALE]) {
+		let output;
+		try {
+			output = await getExecutor().runFileAsync(binary, ["status", "--json"], { timeoutMs: 5e3 });
+		} catch {
+			continue;
+		}
+		return parseTailscaleStatus(output);
+	}
+	return null;
+}
+function hello({ url, servername, host }, auth) {
+	return new Promise((resolve) => {
+		const socket = new WebSocket(url, {
+			handshakeTimeout: HELLO_TIMEOUT_MS,
+			servername,
+			headers: { Host: host }
+		});
+		const done = (reply) => {
+			clearTimeout(timer);
+			socket.removeAllListeners();
+			socket.on("error", () => {});
+			socket.close();
+			resolve(reply);
+		};
+		const timer = setTimeout(() => done({ failed: "no reply in time" }), HELLO_TIMEOUT_MS);
+		socket.on("open", () => {
+			socket.send(JSON.stringify({
+				id: 1,
+				method: "hello",
+				params: {
+					protocol: 1,
+					client: {
+						name: "stim",
+						version: "1"
+					},
+					auth
+				}
+			}));
+		});
+		socket.on("message", (data) => {
+			let message;
+			try {
+				message = JSON.parse(String(data));
+			} catch {
+				message = null;
+			}
+			if (isJsonObject(message) && ("result" in message || "error" in message)) return done(message);
+			done({ failed: "the reply was not a hello result" });
+		});
+		socket.on("error", (error) => done({ failed: error.message }));
+		socket.on("close", () => done({ failed: "the connection closed before a reply" }));
+	});
+}
+const realIo = {
+	status: tailscaleStatus,
+	hello
+};
+async function pinnedEndpoint$1(credential, status = tailscaleStatusAsync) {
+	return pinnedEndpoint(credential, parseMachine(credential.machine) ? await status() : null);
+}
+//#endregion
+export { withNativeBuildRun as S, nativeRunHolder as _, markApproved as a, runCancellation as b, pinnedEndpoint$1 as c, NATIVE_RUN_LOCK as d, NATIVE_RUN_WAIT_MS as f, describeNativeRunHolder as g, decideStopAction as h, lapsedLine as i, realIo as l, clearNativeRunCancel as m, findPeer$1 as n, parseMachine$1 as o, cancelledFailure as p, isLapsed as r, pendingReport as s, endpoint as t, requestedLine as u, nativeRunWaitNotice as v, runCancellationSignal as x, requestNativeRunCancel as y };

package/dist/toolchain-BIupIro1.mjs

@@ -0,0 +1,2 @@
+import { s as macosToolchain } from "./toolchain-DqyDXs30.mjs";
+export { macosToolchain };