stim 1.14.0 → 1.16.0

package/dist/{xcode-Cp5KvK9x.mjs → toolchain-DkUflduf.mjs}

@@ -1,16 +1,145 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { r as register } from "./cache-manifest-C68QQ0ua.mjs";
-import { O as workspaceDerivedData, T as sharedCompilationCache } from "./metro-CcEo8Fl8.mjs";
-import { f as resolvePackageJson } from "./project-CWlvEaeN.mjs";
-import { a as spawnDeclared } from "./spawn-claims-Drw_o-Fb.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { r as register } from "./cache-manifest-DnUHBJaU.mjs";
 import { t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-DVcpw6eE.mjs";
-import { G as resolveOptimizations } from "./settings-D61iNOsB.mjs";
-import { t as cleanLine } from "./server-expo-BVuwQ65v.mjs";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { a as formatElapsed, l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { Z as resolveOptimizations } from "./settings-oTSkkNrM.mjs";
+import { p as resolvePackageJson } from "./project-Du91Ilvc.mjs";
+import { _ as workspaceDerivedData, f as sharedCcache$1, p as sharedCompilationCache$1, x as workspaceLogsDir$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { a as spawnDeclared } from "./spawn-claims-D0XfSe8u.mjs";
+import { o as androidHome } from "./android-B_NumVyQ.mjs";
+import { t as cleanLine } from "./server-expo-MC0rHlOC.mjs";
+import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { stimBuildDigest } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
 import chalk from "chalk";
+const CCACHE_SLOPPINESS = "pch_defines,time_macros";
+const STATS_LOG_FILE = "ccache-stats.log";
+const CCACHE_UNAVAILABLE = {
+	status: "unavailable",
+	hits: null,
+	misses: null,
+	hitRatePercent: null
+};
+const CCACHE_NOT_RUN = {
+	status: "not-run",
+	hits: null,
+	misses: null,
+	hitRatePercent: null
+};
+function ccacheStatsLog(root) {
+	return join(workspaceLogsDir$1(root), STATS_LOG_FILE);
+}
+function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog }) {
+	return {
+		CMAKE_C_COMPILER_LAUNCHER: binary,
+		CMAKE_CXX_COMPILER_LAUNCHER: binary,
+		CCACHE_DIR: dir,
+		CCACHE_BASEDIR: workspaceRoot,
+		CCACHE_NOHASHDIR: "true",
+		CCACHE_SLOPPINESS,
+		CCACHE_MAXSIZE: "5G",
+		CCACHE_STATSLOG: statsLog
+	};
+}
+function parseCcacheBinary(output) {
+	const first = String(output ?? "").split("\n")[0]?.trim();
+	if (!first || !isAbsolute(first)) return null;
+	return first;
+}
+const CMAKE_LAUNCHER = /CMAKE_(C|CXX)_COMPILER_LAUNCHER\b/;
+function projectCmakeLauncher(source) {
+	if (typeof source !== "string") return null;
+	const match = CMAKE_LAUNCHER.exec(source);
+	return match ? `CMAKE_${match[1]}_COMPILER_LAUNCHER` : null;
+}
+const HIT_COUNTERS = /* @__PURE__ */ new Set(["direct_cache_hit", "preprocessed_cache_hit"]);
+function parseCcacheStatsLog(text) {
+	if (typeof text !== "string") return null;
+	let hits = 0;
+	let misses = 0;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (HIT_COUNTERS.has(line)) hits += 1;
+		else if (line === "cache_miss") misses += 1;
+	}
+	const total = hits + misses;
+	if (total === 0) return null;
+	return {
+		status: "reported",
+		hits,
+		misses,
+		hitRatePercent: Math.round(hits / total * 1e3) / 10
+	};
+}
+function readCcacheActivity(statsLog) {
+	let text;
+	try {
+		text = readFileSync(statsLog, "utf-8");
+	} catch {
+		return CCACHE_UNAVAILABLE;
+	}
+	return parseCcacheStatsLog(text) ?? CCACHE_UNAVAILABLE;
+}
+function ccacheActivityLine(activity) {
+	if (activity.status === "reported") return `${activity.hits} hits / ${activity.misses} misses (${activity.hitRatePercent}%)`;
+	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
+	return "unavailable; no C++ compile went through ccache";
+}
+function lookupCcache() {
+	try {
+		return parseCcacheBinary(getExecutor().findExecutable("ccache"));
+	} catch {
+		return null;
+	}
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function canonical(root) {
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+function resolveCcache({ root, dir = sharedCcache$1(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
+	const binary = lookup();
+	if (!binary) {
+		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
+		return null;
+	}
+	const declared = projectCmakeLauncher(readOrNull(join(root, "android", "app", "build.gradle")));
+	if (declared) {
+		onNote(chalk.dim(phaseLine("cache", `ccache off (android/app/build.gradle sets ${declared} itself)`)));
+		return null;
+	}
+	const statsLog = ccacheStatsLog(root);
+	register({
+		dir,
+		name: "ccache",
+		prune: "atomic",
+		note: "ccache keeps itself under CCACHE_MAXSIZE, so it is emptied whole or not at all"
+	});
+	onNote(chalk.dim(phaseLine("cache", `ccache on (${dir})`)));
+	return {
+		dir,
+		statsLog,
+		env: ccacheEnvironment({
+			binary,
+			dir,
+			workspaceRoot: canonical(root),
+			statsLog
+		})
+	};
+}
+//#endregion
 //#region src/engine/bundler.ts
 const COCOAPODS_SPEC = /^ {4}cocoapods \(/m;
 function bundlerPin(root) {
@@ -415,7 +544,7 @@ function parseXcodeMajor(output) {
 function detectXcodeMajor(exec = null) {
 	return parseXcodeMajor((exec || getExecutor()).runQuiet("xcodebuild -version", { timeoutMs: 1e4 }));
 }
-function resolveCompilationCacheSettings({ root, derivedDataPath, exec = null, casPath = sharedCompilationCache(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
+function resolveCompilationCacheSettings({ root, derivedDataPath, exec = null, casPath = sharedCompilationCache$1(), optimizations = resolveOptimizations({}, {}).ios, onNote = (line) => console.error(line) }) {
 	const xcodeMajor = detectXcodeMajor(exec);
 	const ccache = ccacheEnabled(readPodfileProperties(root));
 	const probe = xcodeMajor !== null && xcodeMajor >= 26 && !ccache && optimizations.compilationCache && optimizations.swiftCompilationCache !== false;
@@ -645,7 +774,7 @@ function compilationCacheActivityLine(activity) {
 	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
 	return "unavailable; Xcode did not report reliable statistics";
 }
-async function buildIos({ root, udid = null, logWriter, project = null, scheme = null, configuration = "Debug", sdk = "iphonesimulator", destination = null, derivedDataPath = null, extraArgs = [], compilationCache = void 0, optimizations = resolveOptimizations({}, {}).ios, now = () => Date.now(), exec = null, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), onNote = (line) => console.error(line) }) {
+async function buildIos({ root, udid = null, logWriter, project = null, scheme = null, configuration = "Debug", sdk = "iphonesimulator", destination = null, arch = null, derivedDataPath = null, extraArgs = [], compilationCache = void 0, optimizations = resolveOptimizations({}, {}).ios, now = () => Date.now(), exec = null, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), onNote = (line) => console.error(line) }) {
 	if (!root || typeof root !== "string") throw new TypeError("buildIos requires {root}");
 	if (!logWriter || typeof logWriter.write !== "function") throw new TypeError("buildIos requires {logWriter} with a write() method");
 	if (!udid && !destination) throw new TypeError("buildIos requires {udid} (or an explicit {destination})");
@@ -695,13 +824,18 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 		});
 	}
 	const buildScheme = selected.scheme;
-	const buildSettings = compilationCache === void 0 ? resolveCompilationCacheSettings({
+	const cacheSettings = compilationCache === void 0 ? resolveCompilationCacheSettings({
 		root,
 		derivedDataPath: dd,
 		exec: executor,
 		onNote,
 		optimizations
 	}) : compilationCache || [];
+	const buildSettings = arch ? [
+		...cacheSettings,
+		`ARCHS=${arch}`,
+		"ONLY_ACTIVE_ARCH=YES"
+	] : cacheSettings;
 	const args = xcodebuildArgs({
 		project: resolvedTarget,
 		scheme: buildScheme,
@@ -941,4 +1075,220 @@ async function buildIos({ root, udid = null, logWriter, project = null, scheme =
 	};
 }
 //#endregion
-export { compilationCacheActivityLine as a, readBundleExecutable as c, startBuildHeartbeat as d, tailLines as f, podInstallCommand as h, ccacheEnabled as i, readBundleId as l, bundlerPin as m, HEARTBEAT_INTERVAL_MS as n, detectXcodeMajor as o, describeDiagnostic as p, buildIos as r, discoverXcodeProject as s, COMPILATION_CACHE_NOT_RUN as t, resolveScheme as u };
+//#region src/offload/manifest.ts
+function manifestDigest(entries) {
+	const hash = createHash("sha256");
+	for (const entry of entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) hash.update(`${entry.path}\0${entry.kind}\0${entry.sha256}\n`);
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/offload/toolchain.ts
+const distDir = dirname(fileURLToPath(import.meta.url));
+function quiet(file, args) {
+	return getExecutor().runFileQuiet(file, args, { timeoutMs: 2e4 });
+}
+function iosToolchain() {
+	const xcode = quiet("xcodebuild", ["-version"]);
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		arch: process.arch,
+		xcode: xcode ? xcode.trim().replace(/\n/g, " / ") : null,
+		simulatorSdk: quiet("xcrun", [
+			"--sdk",
+			"iphonesimulator",
+			"--show-sdk-version"
+		])?.trim() ?? null,
+		cocoapods: quiet("pod", ["--version"])?.trim().split("\n").pop()?.trim() ?? null
+	};
+}
+function macosToolchain() {
+	const xcode = quiet("xcodebuild", ["-version"]);
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		arch: process.arch,
+		xcode: xcode ? xcode.trim().replace(/\n/g, " / ") : null,
+		macosSdk: quiet("xcrun", [
+			"--sdk",
+			"macosx",
+			"--show-sdk-version"
+		])?.trim() ?? null
+	};
+}
+/** The major version in a JDK's `release` file, as `JAVA_VERSION="17.0.19"` gives it. */
+function jdkMajor(release) {
+	return /^JAVA_VERSION="(\d+)/m.exec(release)?.[1] ?? null;
+}
+function releaseMajor(home) {
+	try {
+		return jdkMajor(readFileSync(join(home, "release"), "utf8"));
+	} catch {
+		return null;
+	}
+}
+/**
+* The JDK Gradle's wrapper picks: `JAVA_HOME`, else the `java` on PATH, which is the macOS `/usr/bin/java`
+* stub (resolved through `java_home`) unless a real JDK comes first.
+*/
+function localJdk(env = process.env) {
+	if (env.JAVA_HOME) return releaseMajor(env.JAVA_HOME);
+	const java = getExecutor().findExecutable("java");
+	if (java) try {
+		const fromPath = releaseMajor(dirname(dirname(realpathSync(java))));
+		if (fromPath) return fromPath;
+	} catch {}
+	const home = quiet("/usr/libexec/java_home", [])?.trim();
+	return home ? releaseMajor(home) : null;
+}
+function androidToolchain() {
+	return {
+		stimBuild: stimBuildDigest(distDir),
+		arch: process.arch,
+		jdk: localJdk()
+	};
+}
+/** `ndkVersion`, `buildTools` and `compileSdk` from React Native's `gradle/libs.versions.toml`. */
+function parseAndroidRequirements(catalog) {
+	const value = (key) => new RegExp(`^${key}\\s*=\\s*"([^"]+)"`, "m").exec(catalog)?.[1] ?? null;
+	return {
+		ndk: value("ndkVersion"),
+		buildTools: value("buildTools"),
+		compileSdk: value("compileSdk")
+	};
+}
+function androidRequirements(projectRoot) {
+	try {
+		const pkg = createRequire(join(projectRoot, "package.json")).resolve("react-native/package.json");
+		return parseAndroidRequirements(readFileSync(join(dirname(pkg), "gradle", "libs.versions.toml"), "utf8"));
+	} catch {
+		return {
+			ndk: null,
+			buildTools: null,
+			compileSdk: null
+		};
+	}
+}
+/** Runtime identifiers that have at least one available iPhone simulator, from `simctl list devices -j`. */
+function iphoneRuntimes(listed) {
+	const devices = listed?.devices;
+	if (!devices || typeof devices !== "object") return [];
+	return Object.entries(devices).filter(([, list]) => (Array.isArray(list) ? list : []).some((device) => device.isAvailable !== false && typeof device.name === "string" && device.name.startsWith("iPhone"))).map(([runtime]) => runtime).toSorted();
+}
+function listDir(path) {
+	try {
+		return readdirSync(path).filter((entry) => !entry.startsWith(".")).toSorted();
+	} catch {
+		return null;
+	}
+}
+function sdkPackages() {
+	const sdk = androidHome();
+	const platforms = listDir(join(sdk, "platforms"));
+	if (!platforms) return null;
+	return {
+		ndk: listDir(join(sdk, "ndk")) ?? [],
+		buildTools: listDir(join(sdk, "build-tools")) ?? [],
+		platforms
+	};
+}
+function workerToolchain() {
+	let listed = null;
+	try {
+		listed = JSON.parse(quiet("xcrun", [
+			"simctl",
+			"list",
+			"devices",
+			"available",
+			"-j"
+		]) ?? "null");
+	} catch {}
+	return {
+		...iosToolchain(),
+		macosSdk: quiet("xcrun", [
+			"--sdk",
+			"macosx",
+			"--show-sdk-version"
+		])?.trim() ?? null,
+		bundler: quiet("bundle", ["--version"])?.trim() || null,
+		runtimes: iphoneRuntimes(listed),
+		jdk: localJdk(),
+		androidSdk: sdkPackages()
+	};
+}
+/** The API level of an SDK `platforms/` directory: `android-37.0` and `android-37` are both 37. */
+const platformLevel = (dir) => dir.replace(/^android-/, "").split(".")[0];
+function androidMismatches(local, requires, worker) {
+	const out = [];
+	if (!local.jdk || worker.jdk !== local.jdk) out.push({
+		code: "jdk",
+		reason: `JDK ${worker.jdk ?? "none"} there, ${local.jdk ?? "none"} here`
+	});
+	const sdk = worker.androidSdk;
+	if (!sdk) return [...out, {
+		code: "android-sdk",
+		reason: "no Android SDK there"
+	}];
+	if (requires.ndk && !sdk.ndk.includes(requires.ndk)) out.push({
+		code: "ndk",
+		reason: `no NDK ${requires.ndk} there`
+	});
+	if (requires.buildTools && !sdk.buildTools.includes(requires.buildTools)) out.push({
+		code: "build-tools",
+		reason: `no build-tools ${requires.buildTools} there`
+	});
+	if (requires.compileSdk && !sdk.platforms.some((dir) => platformLevel(dir) === requires.compileSdk)) out.push({
+		code: "compile-sdk",
+		reason: `no platform android-${requires.compileSdk} there`
+	});
+	return out;
+}
+/** Why a build machine cannot build like this Mac; empty when it can. */
+function toolchainMismatches(target, worker) {
+	const { local } = target;
+	const out = [];
+	if (!local.stimBuild || worker.stimBuild !== local.stimBuild) out.push({
+		code: "stim-build",
+		reason: `Stim build ${worker.stimBuild ?? "unknown"} there, ${local.stimBuild ?? "unknown"} here`
+	});
+	if (worker.arch !== local.arch) out.push({
+		code: "arch",
+		reason: `CPU ${worker.arch} there, ${local.arch} here`
+	});
+	if (target.platform === "android") return [...out, ...androidMismatches(target.local, target.requires, worker)];
+	if (target.platform === "macos") {
+		const macos = target.local;
+		if (!macos.xcode || worker.xcode !== macos.xcode) out.push({
+			code: "xcode",
+			reason: `Xcode ${worker.xcode} there, ${macos.xcode} here`
+		});
+		if (!macos.macosSdk || worker.macosSdk !== macos.macosSdk) out.push({
+			code: "macos-sdk",
+			reason: `macOS SDK ${worker.macosSdk} there, ${macos.macosSdk} here`
+		});
+		return out;
+	}
+	const ios = target.local;
+	if (!ios.xcode || worker.xcode !== ios.xcode) out.push({
+		code: "xcode",
+		reason: `Xcode ${worker.xcode} there, ${ios.xcode} here`
+	});
+	if (!ios.simulatorSdk || worker.simulatorSdk !== ios.simulatorSdk) out.push({
+		code: "simulator-sdk",
+		reason: `simulator SDK ${worker.simulatorSdk} there, ${ios.simulatorSdk} here`
+	});
+	if (target.cocoapodsPinned) {
+		if (!worker.bundler) out.push({
+			code: "bundler",
+			reason: "no Bundler there to run the CocoaPods this project's Gemfile.lock pins"
+		});
+	} else if (worker.cocoapods !== ios.cocoapods) out.push({
+		code: "cocoapods",
+		reason: `CocoaPods ${worker.cocoapods} there, ${ios.cocoapods} here`
+	});
+	if (target.runtime && !worker.runtimes.includes(target.runtime)) out.push({
+		code: "runtime",
+		reason: `no iPhone simulator on ${target.runtime} there`
+	});
+	return out;
+}
+//#endregion
+export { podInstallCommand as C, projectCmakeLauncher as D, ccacheActivityLine as E, readCcacheActivity as O, bundlerPin as S, CCACHE_UNAVAILABLE as T, readBundleId as _, toolchainMismatches as a, tailLines as b, COMPILATION_CACHE_NOT_RUN as c, buildIos as d, ccacheEnabled as f, readBundleExecutable as g, discoverXcodeProject as h, macosToolchain as i, resolveCcache as k, COMPILATION_CACHE_UNAVAILABLE as l, detectXcodeMajor as m, androidToolchain as n, workerToolchain as o, compilationCacheActivityLine as p, iosToolchain as r, manifestDigest as s, androidRequirements as t, HEARTBEAT_INTERVAL_MS as u, resolveScheme as v, CCACHE_NOT_RUN as w, describeDiagnostic as x, startBuildHeartbeat as y };

package/dist/trigger-Bemu8ytw.mjs

@@ -0,0 +1,65 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-CiTEgMR1.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
+import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-Bk2ouQVL.mjs";
+import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
+import { closeSync, openSync } from "node:fs";
+import { maintenanceChildLogFile, maintenanceRunClaims, readMaintenanceAttempt, readMaintenanceState } from "@stim-cli/core/state";
+import { readClaimSet } from "@stim-cli/core/ownership-claim";
+//#region src/maintenance/trigger.ts
+function triggerMaintenance(trigger, { argv = process.argv.slice(2), platform = process.platform } = {}) {
+	try {
+		const env = process.env;
+		if ([
+			"guide",
+			"settings",
+			"help"
+		].includes(argv[0] ?? "") || argv[0] === "gc" && argv.includes("--delete") || argv.some((arg) => [
+			"--help",
+			"-h",
+			"--version",
+			"-V"
+		].includes(arg))) return;
+		if (env.STIM_MAINTENANCE_CHILD === "1" || (env.STIM_HOME || env.CI) && env.STIM_MAINTENANCE === void 0) return;
+		const settings = resolveMaintenanceSettings();
+		if (settings.mode === "off" || due(readMaintenanceState(), settings, Date.now(), readMaintenanceAttempt()).length === 0) return;
+		const claims = readClaimSet(maintenanceRunClaims());
+		if (claims.live.length || claims.unresolved.length) return;
+		stampAttempt(Date.now());
+		capChildLog();
+		const logFile = maintenanceChildLogFile();
+		const fd = openSync(logFile, "a");
+		try {
+			const cwd = process.cwd();
+			const entry = spawnEntry("maintenance-run");
+			const args = [trigger];
+			const launcher = platform === "win32" ? windowsLauncherArgs({
+				entry,
+				args,
+				cwd,
+				logFile
+			}) : null;
+			const child = getExecutor().spawn(launcher?.file ?? process.execPath, launcher?.args ?? [entry, ...args], {
+				cwd,
+				detached: true,
+				stdio: [
+					"ignore",
+					fd,
+					fd
+				],
+				env: {
+					...env,
+					STIM_MAINTENANCE_CHILD: "1",
+					...launcher?.env
+				},
+				...launcher ? { windowsHide: true } : {}
+			});
+			child.on?.("error", () => {});
+			child.unref?.();
+		} finally {
+			closeSync(fd);
+		}
+	} catch {}
+}
+//#endregion
+export { triggerMaintenance as t };

package/dist/trigger-CXts6qt1.mjs

@@ -0,0 +1,2 @@
+import { t as triggerMaintenance } from "./trigger-Bemu8ytw.mjs";
+export { triggerMaintenance };