stim 1.14.0 → 1.16.0

package/dist/native-run-NaBrRFtQ.mjs

@@ -0,0 +1,147 @@
+import { a as formatElapsed } from "./command-output-DnJMdEY-.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-D0XfSe8u.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+//#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(", ")})`;
+	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") {
+		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(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;
+/** 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 }) {
+	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";
+		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) => {
+		const dispose = cancelOnInterrupt({
+			root,
+			claim,
+			write,
+			exit
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			dispose();
+		}
+	}, {
+		external: true,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawns: true,
+		details: { ...details },
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
+export { decideStopAction as a, nativeRunWaitNotice as c, withNativeBuildRun as d, clearNativeRunCancel as i, requestNativeRunCancel as l, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/{native-runtime-DjBHRg5m.mjs → native-runtime-DBzRnEKS.mjs}

@@ -1,13 +1,17 @@
-import { S as ensureWorkspaceStorage, c as resolveProjectMetro, h as readWorkspaceState$1 } from "./metro-CcEo8Fl8.mjs";
-import { l as phaseLine } from "./command-output-DVcpw6eE.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-Deg4tB3Z.mjs";
-import { s as startDevServer } from "./start-s4RXp1wy.mjs";
+import { l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { S as metroPortSetting } from "./settings-oTSkkNrM.mjs";
+import { l as resolveProjectMetro } from "./metro-BeK1ZPz1.mjs";
+import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-B8-aJ1_5.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-2DBRizjo.mjs";
+import { c as startDevServer } from "./start-ClDfwXa4.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, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
-	const held = port === null ? null : (await resolve(port, root)).metro;
+	const pin = metroPortSetting(root);
+	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 {
 		ok: true,
 		port,

package/dist/{ndjson-CDY9IkVC.mjs → ndjson-PclOIwVY.mjs}

@@ -1,7 +1,7 @@
 import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { dirname } from "path";
 import { rotateLog } from "@stim-cli/core";
-import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations } from "@stim-cli/core/state";
+import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1 } from "@stim-cli/core/state";
 //#region src/ndjson.ts
 const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
@@ -111,4 +111,4 @@ function stamp(record) {
 	};
 }
 //#endregion
-export { parseNdjsonLine as a, levelRank as i, SOURCES as n, readNdjsonGenerations as o, createNdjsonWriter as r, LEVELS as t };
+export { parseNdjsonLine as a, levelRank as i, SOURCES as n, readNdjsonGenerations$1 as o, createNdjsonWriter as r, LEVELS as t };

package/dist/offload-worker.d.mts

@@ -0,0 +1,122 @@
+import "./ndjson-Du3j0AQ9.mjs";
+import "./state-B4PQFXMW.mjs";
+import { readFileSync } from "fs";
+import "@stim-cli/core/state";
+import "@expo/fingerprint";
+import "@stim-cli/core/protocol";
+//#region src/engine/build-facts.d.ts
+interface CompilationCacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  cacheableTasks: number | null;
+  hitRatePercent: number | null;
+  swiftTargetsWithoutExplicitModules?: number;
+}
+interface CcacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  misses: number | null;
+  hitRatePercent: number | null;
+}
+//#endregion
+//#region src/optimizations.d.ts
+interface Optimizations {
+  buildCache: boolean;
+  remoteBuildCache: boolean;
+  releaseBundleSwap: boolean;
+  metroSharedCache: boolean;
+  metroWarmup: boolean;
+  ios: {
+    compilationCache: boolean;
+    swiftCompilationCache: boolean | null;
+    prefixMapping: boolean;
+  };
+  android: {
+    compilerCache: "ccache" | "cas" | "none";
+    casToolchain: string | null;
+    compilerCacheFallback: CompilerCacheFallback | null;
+    pch: "auto" | "on" | "off";
+    gradleBuildCache: boolean;
+    targetAbiOnly: boolean;
+  };
+}
+interface CompilerCacheFallback {
+  key: string;
+  reason: string;
+  fromEnvironment: boolean;
+  manifest: string | null;
+}
+//#endregion
+//#region src/offload/client.d.ts
+/** The Gradle choices that shape the APK, so the machine builds what this Mac's cache key describes. */
+interface AndroidBuildOptions {
+  variant: string | null;
+  abi: string | null;
+  gradleBuildCache: boolean;
+  pch: "auto" | "on" | "off";
+  compilerCache: "ccache" | "none";
+}
+//#endregion
+//#region src/offload/worker.d.ts
+/** One file of the client's checkout, as `git ls-files -co --exclude-standard` lists it. */
+interface ManifestEntry {
+  path: string;
+  kind: "file" | "exec" | "link";
+  size: number;
+  sha256: string;
+}
+/** What stim-server hands this process on stdin; it has already checked every path and blob. */
+interface WorkerJob {
+  job: string;
+  area: string;
+  blobs: string;
+  manifest: ManifestEntry[];
+  platform: "ios" | "android" | "macos";
+  macos: {
+    product: string;
+    infoPlist: string;
+    bundleId: string;
+    resources?: Record<string, string>;
+    assetCatalog?: string | null;
+  } | null;
+  swiftpmCache: string;
+  project: string;
+  packageName: string | null;
+  isExpo: boolean;
+  configuration: string | null;
+  scheme: string | null;
+  runtime: string | null;
+  android: AndroidBuildOptions | null;
+  expectedFingerprint: string;
+  optimizations: Optimizations["ios"] | null;
+  /** How long the client's Gradle daemon stays warm after an Android build; 0 or absent stops it when the build ends. */
+  gradleDaemonIdleMs?: number;
+}
+interface WorkerTimings {
+  syncMs: number;
+  depsMs: number;
+  prebuildMs: number;
+  podsMs: number;
+  fingerprintMs: number;
+  buildMs: number;
+  packageMs: number;
+}
+type WorkerResult = {
+  ok: true;
+  artifact: {
+    path: string;
+    name: string;
+    size: number;
+    sha256: string;
+  };
+  fingerprint: string;
+  compilationCache: CompilationCacheActivity | CcacheActivity | Record<string, never>;
+  timings: WorkerTimings;
+} | {
+  ok: false;
+  code: string;
+  message: string;
+  timings: WorkerTimings;
+};
+//#endregion
+export { ManifestEntry, WorkerJob, WorkerResult, WorkerTimings };