stim 1.20.2 → 1.22.0

package/dist/swiftpm-macos-BIak-Rxv.mjs

@@ -0,0 +1,532 @@
+import { d as spawnDeclared, t as getExecutor, y as trackReportResource } from "./exec-DEoAhcze.mjs";
+import { i as sharedBuildCache } from "./paths-DQtTgsBf.mjs";
+import { G as resolveCacheProviderConfig, L as projectSettingsContextAsync, Nt as repoRootAsync, tt as settingValueAt } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { d as runCancellationSignal } from "./native-run-NwUuxbkg.mjs";
+import "./build-cache-Dv7RN200.mjs";
+import { l as artifactCachePolicy, p as resolveOptimizations } from "./errors-ccaPc4ox.mjs";
+import { l as macosToolchainAsync } from "./toolchain-DpJMHq0n.mjs";
+import { r as nativeFileDigest } from "./native-source-Y0yLhFyQ.mjs";
+import { a as validateInfoPlist, i as stageBundle, n as resolveBundleExtras, r as setBundleName, t as reidentifyBundle } from "./stage-Bps5oius.mjs";
+import { t as validateMacosArtifactPlatform } from "./artifact-platform-CXcmX_j3.mjs";
+import { t as logLines } from "./run-DidHghD1.mjs";
+import { n as swiftpmArtifactInputs, r as swiftpmArtifactSnapshot, t as readSwiftpmArtifactToolchain } from "./swiftpm-artifact-inputs-DFcGsXDP.mjs";
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { parseHostedAppManifest } from "@stim-cli/core/state";
+import { cp, lstat, mkdir, mkdtemp, open, readdir, readlink, realpath, rm, symlink, writeFile } from "node:fs/promises";
+import { buildResolveTimeoutMs, buildUploadTimeoutMs, createFilesystemFileCache, loadCacheProvider } from "@stim-cli/cache";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+//#region src/macos/artifact-file.ts
+const MAGIC = Buffer.from("STIMMAC1\n");
+const MAX_HEADER_BYTES = 16777216;
+const canonical = (path) => path.normalize("NFC").toLowerCase();
+async function bundleFiles(bundle, signal) {
+	const files = [];
+	const directories = [];
+	const walk = async (path) => {
+		signal.throwIfAborted();
+		const absolute = join(bundle, path);
+		const info = await lstat(absolute);
+		if (info.isDirectory()) {
+			if (path) directories.push(path);
+			for (const entry of await readdir(absolute)) await walk(path ? `${path}/${entry}` : entry);
+		} else if (info.isFile()) files.push({
+			path,
+			kind: info.mode & 73 ? "exec" : "file",
+			...await nativeFileDigest(absolute, signal)
+		});
+		else if (info.isSymbolicLink()) {
+			const bytes = Buffer.from(await readlink(absolute));
+			files.push({
+				path,
+				kind: "link",
+				size: bytes.length,
+				sha256: createHash("sha256").update(bytes).digest("hex")
+			});
+		} else throw new Error("The cached macOS bundle contains an unsupported file.");
+	};
+	await walk("");
+	const parsed = parseHostedAppManifest(files);
+	if (!parsed || directories.length > 2e4) throw new Error("The cached macOS bundle has an invalid file inventory.");
+	return {
+		files: parsed,
+		directories: directories.toSorted()
+	};
+}
+async function packMacosArtifact(bundle, key, output, signal) {
+	const { files, directories } = await bundleFiles(bundle, signal);
+	const metadata = Buffer.from(JSON.stringify({
+		key,
+		files,
+		directories
+	}));
+	if (metadata.length > MAX_HEADER_BYTES) throw new Error("The cached macOS bundle receipt is too large.");
+	const header = Buffer.alloc(MAGIC.length + 4);
+	MAGIC.copy(header);
+	header.writeUInt32BE(metadata.length, MAGIC.length);
+	const payload = async function* () {
+		yield header;
+		yield metadata;
+		for (const file of files) {
+			signal.throwIfAborted();
+			const hash = createHash("sha256");
+			let size = 0;
+			const path = join(bundle, file.path);
+			const input = file.kind === "link" ? [Buffer.from(await readlink(path))] : createReadStream(path, { signal });
+			for await (const bytes of input) {
+				hash.update(bytes);
+				size += bytes.length;
+				yield bytes;
+			}
+			if (size !== file.size || hash.digest("hex") !== file.sha256) throw new Error("The macOS bundle changed while its cache entry was packed.");
+		}
+	};
+	await pipeline(Readable.from(payload()), createWriteStream(output, {
+		flags: "wx",
+		mode: 384
+	}), { signal });
+}
+async function readExactly(file, size, position, signal) {
+	const bytes = Buffer.alloc(size);
+	let offset = 0;
+	while (offset < size) {
+		signal.throwIfAborted();
+		const read = await file.read(bytes, offset, size - offset, position + offset);
+		if (!read.bytesRead) throw new Error("The cached macOS entry is truncated.");
+		offset += read.bytesRead;
+	}
+	return bytes;
+}
+async function unpackMacosArtifact(source, key, bundle, signal) {
+	signal.throwIfAborted();
+	const file = await open(source, "r");
+	try {
+		const header = await readExactly(file, MAGIC.length + 4, 0, signal);
+		const size = header.readUInt32BE(MAGIC.length);
+		if (!header.subarray(0, MAGIC.length).equals(MAGIC) || size === 0 || size > MAX_HEADER_BYTES) throw new Error("The cached macOS entry has an unsupported header.");
+		const metadata = JSON.parse((await readExactly(file, size, header.length, signal)).toString("utf8"));
+		const files = parseHostedAppManifest(metadata?.files);
+		if (metadata?.key !== key || !files) throw new Error("The cached macOS entry has an invalid identity or inventory.");
+		const directories = metadata.directories;
+		if (!Array.isArray(directories) || directories.length > 2e4 || !directories.every((path) => typeof path === "string" && path.length > 0 && path.length <= 1024 && !/[\\\0\r\n]/.test(path) && path.split("/").every((part) => part && part !== "." && part !== ".."))) throw new Error("The cached macOS entry has invalid directories.");
+		const filePaths = new Set(files.map((entry) => canonical(entry.path)));
+		for (const path of directories) {
+			let ancestor = canonical(path);
+			while (ancestor !== ".") {
+				if (filePaths.has(ancestor)) throw new Error("A cached macOS directory overlaps a file or link.");
+				ancestor = posix.dirname(ancestor);
+			}
+		}
+		let position = header.length + size;
+		if ((await file.stat()).size !== position + files.reduce((sum, entry) => sum + entry.size, 0)) throw new Error("The cached macOS entry has an invalid payload length.");
+		await mkdir(bundle, { mode: 448 });
+		for (const path of directories) {
+			signal.throwIfAborted();
+			await mkdir(join(bundle, path), {
+				recursive: true,
+				mode: 493
+			});
+		}
+		const links = [];
+		for (const entry of files) {
+			signal.throwIfAborted();
+			const path = join(bundle, entry.path);
+			await mkdir(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			if (entry.kind === "link") {
+				const bytes = await readExactly(file, entry.size, position, signal);
+				if (createHash("sha256").update(bytes).digest("hex") !== entry.sha256) throw new Error("A cached macOS link differs from its digest.");
+				const target = bytes.toString("utf8");
+				const destination = posix.normalize(posix.join(posix.dirname(entry.path), target));
+				if (!target || !Buffer.from(target).equals(bytes) || /[\\\0\r\n]/.test(target) || posix.isAbsolute(target) || destination === "." || destination === ".." || destination.startsWith("../") || entry.path.startsWith(`${destination}/`)) throw new Error("A cached macOS link leaves its bundle or forms an ancestor cycle.");
+				links.push({
+					path,
+					target
+				});
+			} else {
+				const hash = createHash("sha256");
+				if (entry.size === 0) await writeFile(path, "", {
+					flag: "wx",
+					mode: entry.kind === "exec" ? 493 : 420,
+					signal
+				});
+				else {
+					const bytes = async function* () {
+						for await (const chunk of file.createReadStream({
+							start: position,
+							end: position + entry.size - 1,
+							autoClose: false
+						})) {
+							signal.throwIfAborted();
+							hash.update(chunk);
+							yield chunk;
+						}
+					};
+					await pipeline(Readable.from(bytes()), createWriteStream(path, {
+						flags: "wx",
+						mode: entry.kind === "exec" ? 493 : 420
+					}), { signal });
+				}
+				if (hash.digest("hex") !== entry.sha256) throw new Error("A cached macOS file differs from its digest.");
+			}
+			position += entry.size;
+		}
+		for (const link of links) await symlink(link.target, link.path);
+		const root = await realpath(bundle);
+		for (const link of links) {
+			signal.throwIfAborted();
+			const path = relative(root, await realpath(link.path));
+			if (isAbsolute(path) || path === ".." || path.startsWith(`..${sep}`)) throw new Error("A cached macOS link leaves its bundle.");
+		}
+	} finally {
+		await file.close();
+	}
+}
+//#endregion
+//#region src/macos/artifact-cache.ts
+async function providerCall(call, timeoutMs, context, directory, signal) {
+	signal.throwIfAborted();
+	const controller = new AbortController();
+	const failure = Object.assign(/* @__PURE__ */ new Error(`SwiftPM cache provider cleanup did not finish within 35 seconds. Retained ${directory}.`), {
+		code: "STIM_CLAIM_UNAVAILABLE",
+		reportCleanup: true,
+		remedy: "Confirm that the provider has stopped using the retained directory before removing it and retrying."
+	});
+	const pending = Promise.resolve().then(() => {
+		controller.signal.throwIfAborted();
+		return call(controller.signal);
+	}).then((value) => ({ value }), (error) => ({ error }));
+	let close;
+	const closed = new Promise((settleClosed) => {
+		close = settleClosed;
+	});
+	let cleanup;
+	const finish = () => cleanup ??= (async () => {
+		let timer;
+		if (!await Promise.race([pending.then(() => true), new Promise((settleDrain) => {
+			timer = setTimeout(() => settleDrain(false), 35e3);
+		})]).finally(() => clearTimeout(timer))) throw failure;
+		const result = await pending;
+		if ("error" in result && result.error instanceof Error && "reportCleanup" in result.error) throw result.error;
+	})().finally(() => close());
+	let notifyAbort;
+	const aborted = new Promise((settleAbort) => {
+		notifyAbort = () => settleAbort({ aborted: true });
+	});
+	const childAborted = () => notifyAbort();
+	controller.signal.addEventListener("abort", childAborted, { once: true });
+	const abort = () => controller.abort(signal.reason);
+	signal.addEventListener("abort", abort, { once: true });
+	trackReportResource(context, closed, finish, signal, failure);
+	const deadline = setTimeout(() => controller.abort(), timeoutMs);
+	if (signal.aborted) abort();
+	const outcome = await Promise.race([pending, aborted]);
+	clearTimeout(deadline);
+	signal.removeEventListener("abort", abort);
+	controller.signal.removeEventListener("abort", childAborted);
+	await finish();
+	signal.throwIfAborted();
+	if ("aborted" in outcome) throw new Error("SwiftPM cache provider timed out.");
+	if ("error" in outcome) throw outcome.error;
+	return outcome.value;
+}
+const fileKey = (key) => `swiftpm/v1/${key}`;
+async function contained(path, directory) {
+	const rel = relative(await realpath(directory), await realpath(path));
+	if (!rel || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`) || !(await lstat(path)).isFile()) throw new Error("The shared SwiftPM cache file is outside its download directory or is not a regular file.");
+}
+function swiftpmArtifactCache(context, root, settings, recipe, build) {
+	const declaration = settingValueAt(settings, "macos.artifactInputs");
+	if (!declaration) return void 0;
+	const policy = artifactCachePolicy(resolveOptimizations(settings, context.env), true, false);
+	if (!policy.read) return void 0;
+	const activeSignal = () => runCancellationSignal(context) ?? context.signal;
+	const localRoot = sharedBuildCache();
+	const local = createFilesystemFileCache(join(localRoot, "macos"));
+	const storeLocal = async (key, sourcePath, signal) => {
+		register({
+			dir: localRoot,
+			registeredBy: root,
+			name: "Build cache",
+			prune: "entries",
+			entriesDepth: 2,
+			note: "completed native artifacts keyed on build inputs"
+		});
+		await local.store({
+			key: fileKey(key),
+			sourcePath,
+			overwrite: true,
+			signal
+		});
+	};
+	let provider;
+	const shared = () => provider ??= (async () => {
+		const signal = activeSignal();
+		if (!policy.remote) return null;
+		const settingsContext = await projectSettingsContextAsync(root, void 0, {
+			env: context.env,
+			signal,
+			declareFor: context
+		});
+		const loaded = await loadCacheProvider({
+			projectRoot: root,
+			config: resolveCacheProviderConfig(settingsContext),
+			env: context.env
+		});
+		if (loaded.unavailable) throw new Error(loaded.unavailable);
+		return loaded.provider?.files ?? null;
+	})();
+	const unpack = async (path, key, directory) => {
+		const signal = activeSignal();
+		const bundle = join(directory, "Cached.app");
+		await unpackMacosArtifact(path, key, bundle, signal);
+		await recipe.validateFetched(bundle, recipe.bundleId);
+		await validateMacosArtifactPlatform(context, bundle, recipe.product, signal);
+		return bundle;
+	};
+	const identity = async () => {
+		const signal = activeSignal();
+		return swiftpmArtifactSnapshot(root, declaration, build, await readSwiftpmArtifactToolchain(context, signal, root), context.env, signal);
+	};
+	return {
+		peer: () => policy.remote ? {
+			inputs: swiftpmArtifactInputs(declaration),
+			write: policy.write
+		} : null,
+		identity,
+		async has(key) {
+			const signal = activeSignal();
+			if (!await local.stat({
+				key: fileKey(key),
+				signal
+			})) return false;
+			const directory = await mkdtemp(join(tmpdir(), "stim-macos-cache-plan-"));
+			let retainDirectory = false;
+			try {
+				const source = await local.resolve({
+					key: fileKey(key),
+					destinationDir: directory,
+					signal
+				});
+				if (!source) return false;
+				await unpack(source, key, directory);
+				return true;
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainDirectory = true;
+					throw error;
+				}
+				signal.throwIfAborted();
+				return false;
+			} finally {
+				if (!retainDirectory) await rm(directory, {
+					recursive: true,
+					force: true
+				});
+			}
+		},
+		async restore(key, directory) {
+			const signal = activeSignal();
+			await mkdir(directory, { recursive: true });
+			const cached = await local.resolve({
+				key: fileKey(key),
+				destinationDir: directory,
+				signal
+			});
+			if (cached) try {
+				return {
+					bundle: await unpack(cached, key, directory),
+					tier: "local"
+				};
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) throw error;
+				signal.throwIfAborted();
+				await rm(join(directory, "Cached.app"), {
+					recursive: true,
+					force: true
+				});
+			}
+			const files = await shared();
+			if (!files) return null;
+			const result = await providerCall((childSignal) => files.resolve({
+				key: fileKey(key),
+				destinationDir: directory,
+				signal: childSignal
+			}), buildResolveTimeoutMs(context.env), context, directory, signal);
+			signal.throwIfAborted();
+			if (!result) return null;
+			await contained(result, directory);
+			const bundle = await unpack(result, key, directory);
+			await storeLocal(key, result, signal);
+			return {
+				bundle,
+				tier: "provider"
+			};
+		},
+		async store(key, bundle, directory) {
+			const signal = activeSignal();
+			const canonical = join(directory, "Canonical.app");
+			await cp(bundle, canonical, {
+				recursive: true,
+				verbatimSymlinks: true,
+				filter: () => {
+					signal.throwIfAborted();
+					return true;
+				}
+			});
+			await cp(resolve(root, build.infoPlist), join(canonical, "Contents", "Info.plist"));
+			await reidentifyBundle(context, canonical, recipe.bundleId);
+			await recipe.validateFetched(canonical, recipe.bundleId);
+			const sourcePath = join(directory, "artifact.cache");
+			await packMacosArtifact(canonical, key, sourcePath, signal);
+			if ((await identity()).key !== key) throw new Error("SwiftPM inputs changed while the cache entry was packed.");
+			await storeLocal(key, sourcePath, signal);
+			const files = await shared();
+			if (!files) return;
+			await providerCall((childSignal) => files.store({
+				key: fileKey(key),
+				sourcePath,
+				overwrite: true,
+				signal: childSignal
+			}), buildUploadTimeoutMs(context.env), context, directory, signal);
+			signal.throwIfAborted();
+		}
+	};
+}
+//#endregion
+//#region src/integrations/swiftpm-macos.ts
+function swiftpmMacosProject(root) {
+	return { async prepare(context, settings) {
+		const macos = settings.macos;
+		if (!macos?.product || !macos.infoPlist) throw Object.assign(/* @__PURE__ */ new Error("Set macos.product and macos.infoPlist explicitly in .stim.json. See stim guide macos."), { code: "STIM_BAD_ARG" });
+		const { product, infoPlist } = macos;
+		const { bundleId } = await validateInfoPlist(context, root, product, infoPlist);
+		const repository = realpathSync(await repoRootAsync(root, {
+			env: context.env,
+			signal: context.signal
+		}) ?? root);
+		const extras = resolveBundleExtras(root, repository, macos.resources, macos.assetCatalog);
+		const recipe = {
+			product,
+			arguments: macos.arguments ?? [],
+			bundleId,
+			async compile({ scratch, writer, note }) {
+				await tool(context, root, [
+					"build",
+					"-c",
+					"debug",
+					"--product",
+					product,
+					"--scratch-path",
+					scratch,
+					"--jobs",
+					"2"
+				], writer, note);
+				return tool(context, root, [
+					"build",
+					"-c",
+					"debug",
+					"--scratch-path",
+					scratch,
+					"--show-bin-path"
+				], writer, () => {}, true);
+			},
+			stage: (bin, bundle, id, displayName) => stageBundle(context, root, product, infoPlist, bin, bundle, id, extras, displayName),
+			async validateFetched(bundle, id, displayName) {
+				const executable = join(bundle, "Contents", "MacOS", product);
+				const plist = JSON.parse(await getExecutor().runFileAsync("plutil", [
+					"-convert",
+					"json",
+					"-o",
+					"-",
+					join(bundle, "Contents", "Info.plist")
+				], {
+					timeoutMs: 1e4,
+					declareFor: context
+				}));
+				if (plist.CFBundleIdentifier !== id || plist.CFBundleExecutable !== product || !existsSync(executable)) throw new Error("The fetched macOS bundle does not match the requested identity and executable.");
+				for (const destination of [...Object.keys(extras.resources), ...extras.assetCatalog ? ["Assets.car"] : []]) if (!existsSync(join(bundle, "Contents", "Resources", destination))) throw new Error(`The fetched macOS bundle lacks declared resource ${destination}.`);
+				if (displayName !== void 0) {
+					await setBundleName(context, join(bundle, "Contents", "Info.plist"), displayName);
+					await getExecutor().runFileAsync("codesign", [
+						"--force",
+						"--sign",
+						"-",
+						bundle
+					], {
+						timeoutMs: "unbounded",
+						declareFor: context
+					});
+				}
+				await getExecutor().runFileAsync("codesign", [
+					"--verify",
+					"--strict",
+					bundle
+				], {
+					timeoutMs: "unbounded",
+					declareFor: context
+				});
+			},
+			offload: {
+				target: async () => ({
+					platform: "macos",
+					local: await macosToolchainAsync()
+				}),
+				request: (id) => ({
+					platform: "macos",
+					product,
+					infoPlist: relative(root, resolve(root, infoPlist)),
+					bundleId: id,
+					resources: Object.fromEntries(Object.entries(extras.resources).map(([destination, source]) => [destination, relative(repository, source)])),
+					assetCatalog: extras.assetCatalog ? relative(repository, extras.assetCatalog) : null
+				})
+			}
+		};
+		recipe.cache = swiftpmArtifactCache(context, root, settings, recipe, {
+			product,
+			infoPlist,
+			resources: Object.fromEntries(Object.entries(extras.resources).map(([destination, source]) => [destination, relative(root, source)])),
+			assetCatalog: extras.assetCatalog ? relative(root, extras.assetCatalog) : null
+		});
+		return recipe;
+	} };
+}
+async function tool(context, root, args, writer, note, capture = false) {
+	const child = spawnDeclared(context, () => getExecutor().spawn("swift", args, {
+		cwd: root,
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	}));
+	let stdout = "";
+	child.stdout?.on("data", (chunk) => {
+		if (capture) stdout += chunk.toString("utf8");
+	});
+	const write = (msg) => {
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "debug",
+			msg
+		});
+		note(msg);
+	};
+	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(/* @__PURE__ */ new Error(`swift ${args[0]} failed (${code}). See stim logs --source build.`)));
+	});
+	return stdout.trim();
+}
+//#endregion
+export { swiftpmMacosProject };

package/dist/toolchain-BY8X8HXx.mjs

@@ -0,0 +1,2 @@
+import { c as macosToolchain, l as macosToolchainAsync } from "./toolchain-DpJMHq0n.mjs";
+export { macosToolchain, macosToolchainAsync };