stim 1.14.0 → 1.16.0

package/dist/offload-worker.mjs

@@ -0,0 +1,606 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
+import { D as fingerprintProject, M as refingerprintAfterMutation } from "./device-lease-D-hLqx1b.mjs";
+import { T as CCACHE_UNAVAILABLE, d as buildIos, k as resolveCcache, o as workerToolchain, s as manifestDigest } from "./toolchain-DkUflduf.mjs";
+import { t as logLines } from "./run-f4vI6EnK.mjs";
+import { a as runPodInstall, n as podsAreStale, r as readPodState } from "./deps-urbmfXig.mjs";
+import { n as recordPrebuild, r as runPrebuild, t as planPrebuild } from "./prebuild-D2fsca_Z.mjs";
+import { a as gradlewPath, i as buildAndroid, r as assembleTaskFor } from "./gradle-BsO1MdsH.mjs";
+import { n as stageBundle, t as resolveBundleExtras } from "./stage-CzaiwFsI.mjs";
+import { u as podAction } from "./support-D4aYJniO.mjs";
+import { createHash } from "node:crypto";
+import { chmodSync, constants, copyFileSync, cpSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+//#region src/offload/worker.ts
+function emit(value) {
+	process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function note(phase, msg) {
+	emit({
+		type: "phase",
+		phase,
+		msg
+	});
+}
+function relayWriter(file) {
+	let written = 0;
+	return {
+		file,
+		write(record) {
+			written += 1;
+			emit({
+				type: "log",
+				record
+			});
+			return true;
+		},
+		close: () => ({
+			file,
+			written,
+			dropped: 0,
+			lastError: null
+		}),
+		get written() {
+			return written;
+		},
+		dropped: 0,
+		lastError: null
+	};
+}
+function blobPath(blobs, sha256) {
+	return join(blobs, sha256.slice(0, 2), sha256);
+}
+/** Whether every directory above `path` inside `root` is a real directory, so removing it cannot leave `root`. */
+function realParents(root, path) {
+	let current = root;
+	for (const part of path.split("/").slice(0, -1)) {
+		current = join(current, part);
+		try {
+			if (!lstatSync(current).isDirectory()) return false;
+		} catch {
+			return false;
+		}
+	}
+	return true;
+}
+/** Makes every directory above `path` inside `root` a real directory, replacing a file or symlink in the way. */
+function ensureParents(root, path) {
+	let current = root;
+	for (const part of path.split("/").slice(0, -1)) {
+		current = join(current, part);
+		let stat;
+		try {
+			stat = lstatSync(current);
+		} catch {
+			mkdirSync(current);
+			continue;
+		}
+		if (stat.isDirectory()) continue;
+		rmSync(current, { force: true });
+		mkdirSync(current);
+	}
+}
+/**
+* Makes `src` hold exactly the manifest's files: a file the manifest names is rewritten unless this process
+* wrote that same content there and nothing touched it since; a file that git would list as untracked and not
+* ignored, and that the manifest does not name, is deleted, as is one the previous manifest named. Ignored
+* files (dependencies, generated native projects) stay, and the fingerprint check covers them.
+*/
+function materialize(job, src) {
+	const recordFile = join(job.area, "mirror.json");
+	let previous = {};
+	try {
+		previous = JSON.parse(readFileSync(recordFile, "utf8"));
+	} catch {}
+	mkdirSync(src, { recursive: true });
+	if (!existsSync(join(src, ".git"))) {
+		getExecutor().runFile("git", [
+			"init",
+			"--quiet",
+			src
+		], { timeoutMs: 3e4 });
+		getExecutor().runFile("git", [
+			"-C",
+			src,
+			"config",
+			"core.excludesFile",
+			"/dev/null"
+		], { timeoutMs: 3e4 });
+	}
+	const next = {};
+	const wanted = /* @__PURE__ */ new Set();
+	let written = 0;
+	for (const entry of job.manifest) {
+		wanted.add(entry.path);
+		const target = join(src, entry.path);
+		const known = previous[entry.path];
+		let stat = null;
+		try {
+			stat = lstatSync(target);
+		} catch {}
+		if (known && stat && known.sha256 === entry.sha256 && known.kind === entry.kind && stat.mtimeMs === known.mtimeMs && stat.size === known.size) {
+			next[entry.path] = known;
+			continue;
+		}
+		ensureParents(src, entry.path);
+		if (stat) rmSync(target, {
+			recursive: true,
+			force: true
+		});
+		const blob = blobPath(job.blobs, entry.sha256);
+		if (entry.kind === "link") symlinkSync(readFileSync(blob, "utf8"), target);
+		else {
+			copyFileSync(blob, target, constants.COPYFILE_FICLONE);
+			chmodSync(target, entry.kind === "exec" ? 493 : 420);
+		}
+		const after = lstatSync(target);
+		next[entry.path] = {
+			sha256: entry.sha256,
+			kind: entry.kind,
+			mtimeMs: after.mtimeMs,
+			size: after.size
+		};
+		written += 1;
+	}
+	const untracked = getExecutor().runFile("git", [
+		"-C",
+		src,
+		"ls-files",
+		"-z",
+		"-o",
+		"--exclude-standard"
+	], {
+		untrimmed: true,
+		timeoutMs: 12e4
+	}).split("\0").filter(Boolean);
+	let removed = 0;
+	for (const path of /* @__PURE__ */ new Set([...untracked, ...Object.keys(previous)])) {
+		if (wanted.has(path) || !realParents(src, path)) continue;
+		try {
+			rmSync(join(src, path), { force: true });
+			removed += 1;
+		} catch {}
+	}
+	const tmp = `${recordFile}.${process.pid}.tmp`;
+	writeFileSync(tmp, JSON.stringify(next));
+	renameSync(tmp, recordFile);
+	return {
+		written,
+		removed
+	};
+}
+function lockfileOf(src) {
+	if (existsSync(join(src, "pnpm-lock.yaml"))) return {
+		file: "pnpm-lock.yaml",
+		command: "pnpm",
+		args: (pkg) => [
+			"install",
+			"--frozen-lockfile",
+			...pkg ? ["--filter", `${pkg}...`] : []
+		]
+	};
+	if (existsSync(join(src, "yarn.lock"))) return {
+		file: "yarn.lock",
+		command: "yarn",
+		args: () => ["install", "--frozen-lockfile"]
+	};
+	if (existsSync(join(src, "package-lock.json"))) return {
+		file: "package-lock.json",
+		command: "npm",
+		args: () => ["ci"]
+	};
+	return null;
+}
+/** Installs JavaScript dependencies when the lockfile, or the install command, changed since the last install. */
+async function ensureDependencies(job, src) {
+	const lock = lockfileOf(src);
+	if (!lock) return;
+	const args = lock.args(job.packageName);
+	const lockfile = readFileSync(join(src, lock.file));
+	const digest = createHash("sha256").update(lockfile).update(JSON.stringify(args)).digest("hex");
+	const marker = join(job.area, "dependencies");
+	const installed = () => writeFileSync(join(job.area, "lockfile"), createHash("sha256").update(lockfile).digest("hex"));
+	if (existsSync(join(src, job.project, "node_modules")) && existsSync(marker)) {
+		if (readFileSync(marker, "utf8") === digest) return installed();
+	}
+	note("deps", `${lock.command} ${args.join(" ")}`);
+	const child = getExecutor().spawn(lock.command, args, {
+		cwd: src,
+		env: {
+			...process.env,
+			CI: "1"
+		},
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const tail = [];
+	const keep = (chunk) => {
+		tail.push(...String(chunk).split("\n").filter(Boolean));
+		tail.splice(0, Math.max(0, tail.length - 5));
+	};
+	child.stdout?.on("data", keep);
+	child.stderr?.on("data", keep);
+	const code = await new Promise((resolve, reject) => {
+		child.on("error", reject);
+		child.on("exit", resolve);
+	});
+	if (code !== 0) throw new Error(`${lock.command} ${args.join(" ")} exited with ${code}: ${tail.join(" | ")}`);
+	writeFileSync(marker, digest);
+	installed();
+}
+/**
+* The generic simulator destination compiles arm64 and x86_64, so the worker names one of its own iPhone
+* simulators on the client's runtime. It is a build destination only: nothing boots or installs on it.
+*/
+function destination(runtime) {
+	try {
+		const device = (JSON.parse(getExecutor().runFileQuiet("xcrun", [
+			"simctl",
+			"list",
+			"devices",
+			"available",
+			"-j"
+		], { timeoutMs: 2e4 }) ?? "{}").devices?.[runtime] ?? []).find((each) => each.name.startsWith("iPhone"));
+		return device ? `id=${device.udid}` : null;
+	} catch {
+		return null;
+	}
+}
+async function sha256Of(path) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path)) hash.update(chunk);
+	return hash.digest("hex");
+}
+async function build(job) {
+	const timings = {
+		syncMs: 0,
+		depsMs: 0,
+		prebuildMs: 0,
+		podsMs: 0,
+		fingerprintMs: 0,
+		buildMs: 0,
+		packageMs: 0
+	};
+	const time = async (key, run) => {
+		const started = Date.now();
+		try {
+			return await run();
+		} finally {
+			timings[key] += Date.now() - started;
+		}
+	};
+	const failed = (code, message) => ({
+		ok: false,
+		code,
+		message,
+		timings
+	});
+	const src = join(job.area, "src");
+	const root = join(src, job.project);
+	const log = relayWriter(join(job.area, "build.ndjson"));
+	const mirrored = await time("syncMs", () => materialize(job, src));
+	const realSrc = realpathSync(src);
+	const realRoot = realpathSync(root);
+	if (realRoot !== realSrc && !realRoot.startsWith(`${realSrc}/`)) return failed("bad-project", `${job.project} leaves the checkout.`);
+	note("sync", `${job.manifest.length} files, ${mirrored.written} written, ${mirrored.removed} removed`);
+	let fingerprint;
+	let compiled;
+	if (job.platform === "macos") {
+		fingerprint = await time("fingerprintMs", () => manifestDigest(job.manifest));
+		if (fingerprint !== job.expectedFingerprint) return failed("fingerprint-mismatch", `the manifest there fingerprints ${fingerprint.slice(0, 12)}, here ${job.expectedFingerprint.slice(0, 12)}`);
+		compiled = await compileMacos(job, root, log, time);
+		if (!compiled.ok) return failed(compiled.code, compiled.message);
+	} else {
+		try {
+			await time("depsMs", () => ensureDependencies(job, src));
+		} catch (error) {
+			return failed("deps-failed", error.message);
+		}
+		const platform = job.platform;
+		const initial = await time("fingerprintMs", () => fingerprintProject(root, { platform }));
+		if (!initial) return failed("no-fingerprint", "The build machine could not fingerprint the project.");
+		const plan = planPrebuild(root, platform, {
+			isExpo: job.isExpo,
+			fingerprint: initial.hash,
+			sources: initial.sources
+		});
+		if (plan === "refuse") return failed("prebuild-refused", `${platform}/ is not generated by prebuild and does not match.`);
+		const mutations = [];
+		if (plan === "generate" || plan === "regenerate") {
+			note("prebuild", plan === "generate" ? `generating ${platform}/` : `regenerating ${platform}/ with --clean`);
+			recordPrebuild(root, platform, null);
+			const result = await time("prebuildMs", () => runPrebuild(root, platform, log, { clean: plan === "regenerate" }));
+			if (result?.failed) return failed("prebuild-failed", result.reason ?? "expo prebuild failed.");
+			mutations.push("prebuild");
+		}
+		if (platform === "ios") {
+			const podState = readPodState(root);
+			const pods = podAction(podState, podsAreStale(podState.lockText, podState.manifestText));
+			if (pods.install) {
+				note("pods", `${pods.reason ?? "Pods are stale"} -> pod install`);
+				const result = await time("podsMs", () => runPodInstall(root, log, { onHeartbeat: (line) => note("pods", line) }));
+				if (result?.failed) return failed("pods-failed", result.reason ?? "pod install failed.");
+				mutations.push("pods");
+			}
+		}
+		fingerprint = initial.hash;
+		if (mutations.length) {
+			const after = await time("fingerprintMs", () => refingerprintAfterMutation({
+				projectRoot: root,
+				platform,
+				previousHash: initial.hash
+			}));
+			if (!after) return failed("no-fingerprint", `No fingerprint after ${mutations.join(", ")}.`);
+			fingerprint = after.hash;
+			if (mutations.includes("prebuild")) recordPrebuild(root, platform, after.hash);
+		}
+		if (fingerprint !== job.expectedFingerprint) return failed("fingerprint-mismatch", `the checkout there fingerprints ${fingerprint.slice(0, 12)}, here ${job.expectedFingerprint.slice(0, 12)}`);
+		compiled = platform === "android" ? await compileAndroid(job, root, log, time) : await compileIos(job, root, log, time);
+		if (!compiled.ok) return failed(compiled.code, compiled.message);
+		const settled = await time("fingerprintMs", () => refingerprintAfterMutation({
+			projectRoot: root,
+			platform,
+			previousHash: fingerprint
+		}));
+		if (!settled || settled.moved) return failed("fingerprint-moved", "The inputs changed during the build there.");
+	}
+	const out = join(job.area, "out", job.job);
+	if (job.platform !== "macos") rmSync(out, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(out, { recursive: true });
+	const archive = join(out, "app.tgz");
+	const name = basename(compiled.path);
+	if (job.platform === "ios") cpSync(compiled.path, join(out, name), {
+		recursive: true,
+		verbatimSymlinks: true,
+		mode: constants.COPYFILE_FICLONE
+	});
+	await time("packageMs", () => getExecutor().runFileAsync("tar", [
+		"-czf",
+		archive,
+		"--options",
+		"gzip:compression-level=1",
+		"-C",
+		dirname(compiled.path),
+		name
+	], { timeoutMs: 6e5 }));
+	const sha256 = await time("packageMs", () => sha256Of(archive));
+	return {
+		ok: true,
+		artifact: {
+			path: archive,
+			name,
+			size: statSync(archive).size,
+			sha256
+		},
+		fingerprint,
+		compilationCache: compiled.cache,
+		timings
+	};
+}
+async function compileMacos(job, root, log, time) {
+	const options = job.macos;
+	if (!options) return {
+		ok: false,
+		code: "bad-request",
+		message: "The job has no SwiftPM options."
+	};
+	const src = join(job.area, "src");
+	const scratch = join(job.area, "macos", job.project.replaceAll("/", "_") || "root");
+	const run = async (args, capture = false) => {
+		const child = getExecutor().spawn("swift", args, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let firstError = null;
+		const tail = [];
+		const write = (msg) => {
+			const plain = stripAnsi(msg);
+			if (firstError === null && /\.swift:\d+:\d+: error:/.test(plain)) firstError = plain;
+			tail.push(plain);
+			if (tail.length > 3) tail.shift();
+			note("build", msg);
+			log.write({
+				src: "build",
+				platform: "macos",
+				level: "debug",
+				msg
+			});
+		};
+		child.stdout?.on("data", (chunk) => {
+			if (capture) stdout += chunk.toString("utf8");
+		});
+		if (child.stdout) logLines(child.stdout, write);
+		if (child.stderr) logLines(child.stderr, write);
+		await new Promise((done, reject) => {
+			child.once("error", reject);
+			child.once("close", (code) => code === 0 ? done() : reject(new Error(firstError ?? (tail.join(" | ") || `swift build failed (${code})`))));
+		});
+		return stdout.trim();
+	};
+	try {
+		const extras = resolveBundleExtras(src, src, options.resources, options.assetCatalog);
+		return await time("buildMs", async () => {
+			await run([
+				"build",
+				"-c",
+				"debug",
+				"--product",
+				options.product,
+				"--scratch-path",
+				scratch,
+				"--cache-path",
+				job.swiftpmCache
+			]);
+			const bin = await run([
+				"build",
+				"-c",
+				"debug",
+				"--scratch-path",
+				scratch,
+				"--cache-path",
+				job.swiftpmCache,
+				"--show-bin-path"
+			], true);
+			const bundle = join(job.area, "out", job.job, `${options.product}.app`);
+			stageBundle(root, options.product, options.infoPlist, bin, bundle, options.bundleId, extras);
+			return {
+				ok: true,
+				path: bundle,
+				cache: {}
+			};
+		});
+	} catch (error) {
+		return {
+			ok: false,
+			code: "swift-failed",
+			message: error.message
+		};
+	}
+}
+async function compileIos(job, root, log, time) {
+	const runtime = job.runtime ?? "";
+	const target = destination(runtime);
+	if (!target) return {
+		ok: false,
+		code: "no-runtime",
+		message: `There is no iPhone simulator on ${runtime} to build for.`
+	};
+	note("build", `xcodebuild for ${runtime}`);
+	const built = await time("buildMs", () => buildIos({
+		root,
+		destination: target,
+		logWriter: log,
+		...job.scheme ? { scheme: job.scheme } : {},
+		...job.configuration ? { configuration: job.configuration } : {},
+		...job.optimizations ? { optimizations: job.optimizations } : {},
+		onHeartbeat: (line) => note("build", line),
+		onNote: (line) => note("build", line)
+	}));
+	if (!built.ok) {
+		const first = built.diagnostics[0]?.message;
+		return {
+			ok: false,
+			code: built.code,
+			message: first ?? (built.tail.slice(-3).join(" | ") || "xcodebuild failed.")
+		};
+	}
+	return {
+		ok: true,
+		path: built.appPath,
+		cache: built.compilationCache
+	};
+}
+/**
+* Stops the Gradle daemons of this client's Gradle home. A daemon calls setsid, so it leaves the build's
+* process group and would outlive the job and its claim.
+*/
+function stopGradleDaemons(root, timeoutMs) {
+	const gradlew = gradlewPath(root);
+	if (!existsSync(gradlew)) return;
+	getExecutor().runFileQuiet(gradlew, ["--stop"], {
+		cwd: dirname(gradlew),
+		timeoutMs
+	});
+}
+/**
+* Gradle reads `org.gradle.daemon.idletimeout` from the user home's gradle.properties, which overrides the
+* project's, so the daemon exits after that idle time instead of Gradle's three hours.
+*/
+function limitDaemonIdle(idleMs) {
+	const home = process.env.GRADLE_USER_HOME;
+	if (!home) return;
+	const file = join(home, "gradle.properties");
+	const wanted = `org.gradle.daemon.idletimeout=${idleMs}\n`;
+	try {
+		if (readFileSync(file, "utf8") === wanted) return;
+	} catch {}
+	mkdirSync(home, { recursive: true });
+	writeFileSync(file, wanted);
+}
+async function compileAndroid(job, root, log, time) {
+	const options = job.android;
+	if (!options) return {
+		ok: false,
+		code: "bad-request",
+		message: "The job has no Gradle options."
+	};
+	const idleMs = job.gradleDaemonIdleMs ?? 0;
+	const keepDaemon = idleMs > 0;
+	limitDaemonIdle(keepDaemon ? idleMs : 6e4);
+	const onNote = (line) => note("build", line);
+	const stop = () => {
+		stopGradleDaemons(root, 4e3);
+		process.exit(143);
+	};
+	process.once("SIGTERM", stop);
+	note("build", `gradle ${assembleTaskFor(options.variant)} for ${options.abi ?? "every ABI"}`);
+	try {
+		const built = await time("buildMs", () => buildAndroid({
+			root,
+			logWriter: log,
+			variant: options.variant,
+			abi: options.abi
+		}, {
+			buildCache: options.gradleBuildCache,
+			pch: options.pch,
+			compilerCacheDisabled: options.compilerCache === "none",
+			ccache: options.compilerCache === "ccache" ? resolveCcache({
+				root,
+				onNote
+			}) : null,
+			onHeartbeat: onNote,
+			onNote
+		}));
+		if (!built.ok) {
+			const first = built.diagnostics[0]?.message;
+			return {
+				ok: false,
+				code: built.code,
+				message: first ?? (built.lastLines.slice(-3).join(" | ") || built.reason)
+			};
+		}
+		return {
+			ok: true,
+			path: built.apkPath,
+			cache: built.ccache ?? CCACHE_UNAVAILABLE
+		};
+	} finally {
+		process.off("SIGTERM", stop);
+		if (!keepDaemon) stopGradleDaemons(root, 6e4);
+	}
+}
+async function main() {
+	const mode = process.argv[2];
+	if (mode === "offer") return emit(workerToolchain());
+	if (mode === "build") {
+		const chunks = [];
+		for await (const chunk of process.stdin) chunks.push(chunk);
+		return emit({
+			type: "result",
+			...await build(JSON.parse(Buffer.concat(chunks).toString("utf8")))
+		});
+	}
+	process.stderr.write("usage: offload-worker offer | build < job.json\n");
+	process.exitCode = 2;
+}
+main().catch((error) => {
+	emit({
+		type: "result",
+		ok: false,
+		code: "worker-crashed",
+		message: String(error?.message ?? error)
+	});
+});
+//#endregion
+export {};

package/dist/{ownership-DyYDF5ww.mjs → ownership-DiA16AsN.mjs}

@@ -1,5 +1,6 @@
-import { O as process_identity_exports } from "./config-lvc7d3C2.mjs";
-import { a as pidExists, b as writeWorkspaceState, h as readWorkspaceState, v as withWorkspaceStateLock } from "./metro-CcEo8Fl8.mjs";
+import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { o as pidExists } from "./metro-BeK1ZPz1.mjs";
+import { c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-B8-aJ1_5.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {