stim 1.18.0 → 1.20.0

package/dist/build-BixRI6sB.mjs

@@ -0,0 +1,462 @@
+import { E as upsertProject, p as getProject, u as getConcurrencyLimits } from "./config-D0LhTY3S.mjs";
+import { K as resolveProjectSettings, W as resolveCacheProviderConfig, a as SETTING_SHAPE_REMEDY } from "./settings-Bbztm4oV.mjs";
+import { _ as waitForBuild, g as releaseBuildLock, j as providerUploadOutcome, m as acquireBuildLock } from "./device-lease-DHOBXGgS.mjs";
+import { i as recordWorkspaceUse, w as workspaceLogsDir, x as workspaceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { _ as detectIsExpo, d as projectRegistry } from "./project-B8_duAzW.mjs";
+import { D as hostSystemImageArch } from "./android-BsYNR81W.mjs";
+import { F as acquireBuildSlot, L as releaseBuildSlot } from "./workspaces-D2xSHBDY.mjs";
+import { At as createRunRecorder, Dt as recordFinishedBuild, Ft as recordRunStats, It as statsProjectKey, Ot as startBuildProgress, jt as readRunEstimates, kt as tapBuildLog } from "./budget-BONq9vXY.mjs";
+import { S as withNativeBuildRun, x as runCancellationSignal } from "./tailnet-CoJUb2tB.mjs";
+import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
+import { d as optimizationBuildProfile, l as artifactCachePolicy } from "./errors-DzkMYh8Q.mjs";
+import { i as checkEasAuth, m as uploadRemote, p as resolveRemote } from "./remote-cache-Bsts6f6Y.mjs";
+import { f as setRemoteLogSink, y as resolveBuildPlacement } from "./client-BLy1Pw2V.mjs";
+import { m as listIosRuntimes } from "./ios-CXLIUxXJ.mjs";
+import { n as ensureWorkspaceStorageSafely } from "./native-runtime-BRmWL7ru.mjs";
+import { A as readBundleId } from "./toolchain-DqyDXs30.mjs";
+import { n as resolveAndroidBuildPlan } from "./plan-BDk2AeY_.mjs";
+import { t as acquireAndroidArtifact } from "./artifact-DClXJNWx.mjs";
+import { i as persistLastBuild, n as finishAndroidUpload } from "./result-BDoRk1k3.mjs";
+import { c as iosProjectPathError, g as resolveIosBuildSetup, m as resolveConfiguration, x as simulatorBuildArch, y as resolveSchemeSelection } from "./support-DCco5fut.mjs";
+import { a as lastBuildRecord } from "./ios-project-B9drt_aY.mjs";
+import { t as acquireIosArtifact } from "./artifact-CnC0mfov.mjs";
+import { constants, copyFileSync, cpSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { basename, join } from "node:path";
+import { loadCacheProvider } from "@stim-cli/cache";
+import { hostSimulatorArch } from "@stim-cli/core";
+//#region src/commands/android/build.ts
+const note$1 = (line) => console.error(line);
+async function buildAndroidOperation(root, options) {
+	const selected = projectRegistry.selectAndroid(root);
+	if ("problem" in selected) throw Object.assign(new Error(selected.problem.message), {
+		code: "STIM_NO_PROJECT",
+		remedy: selected.problem.remedy
+	});
+	const { context: settingsContext, settings } = resolveProjectSettings(root);
+	const integration = await selected.load({
+		context: settingsContext,
+		settings
+	});
+	const phase = (label, line) => note$1(phaseLine(label, line));
+	const plan = resolveAndroidBuildPlan({
+		settings,
+		settingsContext,
+		variant: options.variant ?? null,
+		buildCache: options.buildCache !== false
+	}, {
+		warn: phase,
+		runtimeKind: integration.runtimeKind,
+		variantProblem: integration.variantProblem,
+		detectExpo: () => integration.isExpo
+	});
+	if (!plan.ok) throw Object.assign(new Error(plan.message), plan, { details: { lines: plan.lines } });
+	const placement = resolveBuildPlacement(options.remoteBuild);
+	if (placement.failure) throw Object.assign(new Error(placement.failure.message), placement.failure);
+	if (options.abi !== void 0 && ![
+		"arm64-v8a",
+		"armeabi-v7a",
+		"x86",
+		"x86_64",
+		"all"
+	].includes(options.abi)) throw Object.assign(/* @__PURE__ */ new Error("Android build abi must be arm64-v8a, armeabi-v7a, x86, x86_64 or all."), { code: "STIM_BAD_ARG" });
+	const abi = options.abi === "all" ? null : options.abi ?? (plan.plan.build.targetAbiOnly && !plan.plan.build.release ? hostSystemImageArch() : null);
+	await ensureWorkspaceStorageSafely(root, { note: note$1 });
+	return withNativeBuildRun(root, {
+		command: "build",
+		platform: "android"
+	}, async (claim) => {
+		if (!getProject(root)) upsertProject(root, {});
+		recordWorkspaceUse(root);
+		const started = Date.now();
+		const startedAt = new Date(started).toISOString();
+		const progress = startBuildProgress({
+			root,
+			platform: "android",
+			slot: "default",
+			claim,
+			note: note$1
+		});
+		const logs = workspaceLogsDir(root);
+		const buildLog = join(logs, "build-artifact-android.ndjson");
+		const writer = tapBuildLog(createNdjsonWriter(buildLog, {
+			truncate: true,
+			fields: { platform: "android" }
+		}), progress);
+		setRemoteLogSink((entry) => writer.write(entry));
+		const projectKey = statsProjectKey({
+			root,
+			commonDir: settingsContext.gitCommonDir,
+			repoRoot: settingsContext.repoRoot
+		});
+		const stats = createRunRecorder({
+			platform: "android",
+			write: recordRunStats,
+			now: Date.now,
+			note: note$1,
+			phases: () => progress.durations(),
+			deviceSetup: () => false
+		});
+		stats.setProject(projectKey);
+		progress.estimate(projectKey);
+		const record = {
+			buildMachine: placement.selected,
+			configuration: plan.plan.build.variant
+		};
+		let artifact;
+		let directory;
+		let succeeded = false;
+		const finishRecord = (status, errorCode) => persistLastBuild({
+			root,
+			record,
+			startedAt,
+			durationMs: Date.now() - started,
+			status,
+			errorCode,
+			out: note$1,
+			recordBuild: (at, entry) => recordFinishedBuild(at, entry, { artifactOnly: true })
+		});
+		try {
+			const acquired = await acquireAndroidArtifact({
+				root,
+				buildLog,
+				writer,
+				recipe: integration.artifact({
+					root,
+					buildLog,
+					writer,
+					settings,
+					buildPlan: plan.plan.build,
+					target: { abi },
+					phase,
+					out: note$1,
+					step: progress.step,
+					estimates: () => readRunEstimates({
+						projectKey,
+						platform: "android"
+					})
+				}),
+				targetOffloadRefusal: null,
+				buildPlan: plan.plan.build,
+				cacheProviderConfig: plan.plan.cacheProviderConfig,
+				requestedBuildCache: options.buildCache !== false,
+				easBuild: null,
+				androidPackage: integration.appIds().androidPackage,
+				record,
+				maxBuilds: getConcurrencyLimits().maxBuilds,
+				progress: {
+					phase,
+					out: note$1,
+					stats,
+					step: progress.step,
+					miss: progress.miss,
+					hit: progress.hit,
+					place: progress.place,
+					waitingOn: progress.waitingOn,
+					waitingFor: progress.waitingFor
+				}
+			}, {
+				acquireLock: acquireBuildLock,
+				releaseLock: releaseBuildLock,
+				waitForBuild,
+				easAuth: checkEasAuth,
+				resolveRemoteBuild: resolveRemote,
+				uploadRemoteBuild: uploadRemote,
+				loadCacheProviderModule: loadCacheProvider,
+				acquireSlot: acquireBuildSlot,
+				releaseSlot: releaseBuildSlot,
+				now: Date.now
+			});
+			if (!acquired.ok) throw Object.assign(new Error(acquired.failure.message ?? "Android build failed."), acquired.failure, { details: acquired.failure.extra });
+			artifact = acquired.artifact;
+			if (runCancellationSignal()?.aborted) throw Object.assign(/* @__PURE__ */ new Error("The Android build was cancelled."), { code: "STIM_CANCELLED" });
+			if (!artifact.apkPath) throw Object.assign(/* @__PURE__ */ new Error("The Android build produced no APK."), { code: "STIM_BUILD_FAILED" });
+			const artifacts = join(workspaceDir(root), "artifacts");
+			mkdirSync(artifacts, { recursive: true });
+			directory = mkdtempSync(join(artifacts, "android-"));
+			const apkPath = join(directory, "app.apk");
+			copyFileSync(artifact.apkPath, apkPath, constants.COPYFILE_FICLONE);
+			await finishAndroidUpload(artifact.uploadPending, artifact.remote, phase);
+			const uploaded = providerUploadOutcome(artifact.providerUpload ? await artifact.providerUpload : null, artifact.providerName);
+			if (uploaded) phase("cache", uploaded.line);
+			if (runCancellationSignal()?.aborted) throw Object.assign(/* @__PURE__ */ new Error("The Android build was cancelled."), { code: "STIM_CANCELLED" });
+			record.appPath = apkPath;
+			record.bundleId = artifact.androidPackage;
+			finishRecord("ok");
+			stats.record({
+				failed: false,
+				cacheHit: record.cacheHit === "local" || record.cacheHit === "remote" ? record.cacheHit : false,
+				durationMs: Date.now() - started,
+				offloadedTo: record.offloadedTo,
+				waited: artifact.waitedForBuild
+			});
+			succeeded = true;
+			return {
+				apkPath,
+				androidPackage: artifact.androidPackage,
+				variant: plan.plan.build.variant ?? "debug",
+				abi,
+				cacheKey: record.cacheKey ?? null,
+				cacheHit: record.cacheHit ?? false,
+				cacheSkipped: record.cacheSkipped ?? false,
+				buildMachine: placement.selected,
+				builtOn: record.builtOn ?? null,
+				ccache: artifact.ccache,
+				durationMs: Date.now() - started,
+				logs: { dir: logs }
+			};
+		} catch (error) {
+			const failure = runCancellationSignal()?.aborted ? Object.assign(/* @__PURE__ */ new Error("The Android build was cancelled."), {
+				code: "STIM_CANCELLED",
+				cause: error
+			}) : error;
+			finishRecord("failed", failure.code);
+			stats.record({
+				failed: true,
+				durationMs: Date.now() - started
+			});
+			throw failure;
+		} finally {
+			artifact?.release();
+			if (!succeeded && directory) rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+			writer.close();
+			progress.clear();
+		}
+	}, { write: (line) => phase("lock", line) });
+}
+//#endregion
+//#region src/commands/ios/build.ts
+const note = (line) => console.error(line);
+async function buildIosOperation(root, options) {
+	const selected = projectRegistry.selectIos(root);
+	if ("problem" in selected) throw Object.assign(new Error(selected.problem.message), {
+		code: "STIM_NO_PROJECT",
+		remedy: selected.problem.remedy
+	});
+	const { context, settings } = resolveProjectSettings(root);
+	const projectPathError = iosProjectPathError(settings, root, () => detectIsExpo(root));
+	if (projectPathError) throw Object.assign(new Error(projectPathError), {
+		code: "STIM_BAD_ARG",
+		remedy: SETTING_SHAPE_REMEDY
+	});
+	const integration = await selected.load(settings);
+	const setup = resolveIosBuildSetup(options.remoteBuild, settings, (label, message) => note(phaseLine(label, message)));
+	if (!setup.ok) {
+		const { failure } = setup;
+		throw Object.assign(new Error(failure.message ?? failure.code), failure, { details: failure });
+	}
+	const { buildMachine, optimizations } = setup;
+	const configuration = resolveConfiguration(options.configuration, settings);
+	const buildScheme = resolveSchemeSelection(options, settings);
+	const problem = integration.schemeProblem(buildScheme, configuration);
+	if (problem) throw Object.assign(new Error(problem.message ?? problem.code), problem);
+	if (options.arch !== void 0 && ![
+		"arm64",
+		"x86_64",
+		"all"
+	].includes(options.arch)) throw Object.assign(/* @__PURE__ */ new Error("iOS build arch must be arm64, x86_64 or all."), { code: "STIM_BAD_ARG" });
+	const arch = options.arch === "all" ? null : options.arch ?? simulatorBuildArch({
+		physical: false,
+		remoteArch: null,
+		hostArch: hostSimulatorArch(),
+		configuration
+	});
+	const cache = artifactCachePolicy(optimizations, options.buildCache !== false, integration.runtimeKind(configuration) === "embedded-js");
+	const phase = (label, line) => note(phaseLine(label, line));
+	await ensureWorkspaceStorageSafely(root, { note });
+	return withNativeBuildRun(root, {
+		command: "build",
+		platform: "ios"
+	}, async (claim) => {
+		if (!getProject(root)) upsertProject(root, {});
+		recordWorkspaceUse(root);
+		const started = Date.now();
+		const startedAt = new Date(started).toISOString();
+		const progress = startBuildProgress({
+			root,
+			platform: "ios",
+			slot: "default",
+			claim,
+			note
+		});
+		const logs = workspaceLogsDir(root);
+		const logFile = join(logs, "build-artifact-ios.ndjson");
+		const writer = tapBuildLog(createNdjsonWriter(logFile, {
+			truncate: true,
+			fields: { platform: "ios" }
+		}), progress);
+		setRemoteLogSink((entry) => writer.write(entry));
+		const projectKey = statsProjectKey({
+			root,
+			commonDir: context.gitCommonDir,
+			repoRoot: context.repoRoot
+		});
+		const stats = createRunRecorder({
+			platform: "ios",
+			write: recordRunStats,
+			now: Date.now,
+			note,
+			phases: () => progress.durations(),
+			deviceSetup: () => false
+		});
+		stats.setProject(projectKey);
+		progress.estimate(projectKey);
+		let artifact;
+		let directory;
+		let succeeded = false;
+		const finish = (status, appPath, errorCode) => {
+			try {
+				recordFinishedBuild(root, lastBuildRecord({
+					startedAt,
+					status,
+					appPath,
+					errorCode,
+					configuration,
+					durationMs: Date.now() - started,
+					fingerprint: artifact?.cache.identity?.fingerprint,
+					cacheKey: artifact?.cache.identity?.key,
+					cacheHit: artifact?.cache.hit,
+					cacheSkipped: artifact ? !artifact.cache.readEnabled : !cache.read,
+					bundleId: artifact?.bundleId,
+					buildMachine,
+					builtOn: artifact?.cache.builtOn,
+					offloadedTo: artifact?.cache.offloadedTo,
+					offloadFallback: artifact?.cache.offloadFallback
+				}), { artifactOnly: true });
+			} catch (error) {
+				note(phaseLine("state", `could not record the build: ${error?.message || error}`));
+			}
+		};
+		try {
+			const acquired = await acquireIosArtifact({
+				root,
+				logFile,
+				configuration,
+				buildMachine,
+				physical: false,
+				recipe: integration.artifact({
+					root,
+					logFile,
+					configuration,
+					buildScheme,
+					buildProfile: optimizationBuildProfile("ios", optimizations),
+					target: {
+						udid: null,
+						destination: "generic/platform=iOS Simulator",
+						sdk: "iphonesimulator",
+						arch,
+						keyArch: arch,
+						offloadRuntime: () => listIosRuntimes().toSorted((a, b) => b.version.localeCompare(a.version, void 0, { numeric: true }))[0]?.identifier ?? null,
+						...arch ? { hostedArchitecture: arch } : {},
+						offloadRefusal: null
+					},
+					device: null,
+					optimizations: optimizations.ios,
+					cache,
+					phase,
+					note,
+					logWriter: () => writer,
+					estimates: () => readRunEstimates({
+						projectKey,
+						platform: "ios"
+					}),
+					step: progress.step,
+					setPodsMs: (ms) => stats.setPodsMs(ms)
+				}),
+				cache: {
+					policy: cache,
+					providerConfig: resolveCacheProviderConfig(context),
+					disabledByFlag: options.buildCache === false
+				},
+				easBuild: null,
+				maxBuilds: getConcurrencyLimits().maxBuilds,
+				progress: {
+					phase,
+					note,
+					logWriter: () => writer,
+					stats,
+					step: progress.step,
+					miss: progress.miss,
+					hit: progress.hit,
+					place: progress.place,
+					waitingOn: progress.waitingOn,
+					waitingFor: progress.waitingFor
+				}
+			}, {
+				loadCacheProvider,
+				checkEasAuth,
+				resolveRemote,
+				uploadRemote,
+				acquireBuildLock,
+				releaseBuildLock,
+				waitForBuild,
+				acquireBuildSlot,
+				releaseBuildSlot,
+				now: Date.now
+			});
+			if (!acquired.ok) throw Object.assign(new Error(acquired.failure.message ?? "The iOS build failed."), acquired.failure);
+			artifact = acquired.artifact;
+			artifact.bundleId ??= readBundleId(artifact.path) ?? integration.bundleId();
+			if (runCancellationSignal()?.aborted) throw Object.assign(/* @__PURE__ */ new Error("The iOS build was cancelled."), { code: "STIM_CANCELLED" });
+			const artifacts = join(workspaceDir(root), "artifacts");
+			mkdirSync(artifacts, { recursive: true });
+			directory = mkdtempSync(join(artifacts, "ios-"));
+			const appPath = join(directory, basename(artifact.path));
+			cpSync(artifact.path, appPath, {
+				recursive: true,
+				verbatimSymlinks: true,
+				mode: constants.COPYFILE_FICLONE
+			});
+			await artifact.completeUploads();
+			if (runCancellationSignal()?.aborted) throw Object.assign(/* @__PURE__ */ new Error("The iOS build was cancelled."), { code: "STIM_CANCELLED" });
+			finish("ok", appPath);
+			stats.record({
+				failed: false,
+				durationMs: Date.now() - started,
+				cacheHit: artifact.cache.hit === "local" || artifact.cache.hit === "remote" ? artifact.cache.hit : false,
+				offloadedTo: artifact.cache.offloadedTo,
+				waited: artifact.cache.waitedForBuild
+			});
+			succeeded = true;
+			return {
+				appPath,
+				bundleId: artifact.bundleId,
+				configuration: configuration ?? "Debug",
+				scheme: buildScheme ?? null,
+				arch,
+				cacheKey: artifact.cache.identity?.key ?? null,
+				cacheHit: artifact.cache.hit,
+				cacheSkipped: !artifact.cache.readEnabled,
+				buildMachine,
+				builtOn: artifact.cache.builtOn ?? null,
+				compilationCache: artifact.cache.compilation,
+				durationMs: Date.now() - started,
+				logs: { dir: logs }
+			};
+		} catch (error) {
+			const failure = runCancellationSignal()?.aborted ? Object.assign(/* @__PURE__ */ new Error("The iOS build was cancelled."), {
+				code: "STIM_CANCELLED",
+				cause: error
+			}) : error;
+			finish("failed", void 0, failure.code);
+			stats.record({
+				failed: true,
+				durationMs: Date.now() - started
+			});
+			throw failure;
+		} finally {
+			artifact?.release();
+			if (!succeeded && directory) rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+			writer.close();
+			progress.clear();
+		}
+	}, { write: (line) => phase("lock", line) });
+}
+//#endregion
+export { buildAndroidOperation as n, buildIosOperation as t };