Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

7.3 KB
Raw Blame
import { spawn } from "node:child_process";
import { readFileSync } from "node:fs";
import { constants } from "node:os";
import path from "node:path";
import { setTimeout as wait } from "node:timers/promises";
import { fileURLToPath } from "node:url";
import { stripVTControlCharacters } from "node:util";

const desktopDirectory = fileURLToPath(
	new URL("../apps/desktop/", import.meta.url),
);
const retryDelays = [15_000, 30_000];
const outputTailLimit = 64 * 1024;

export function resolveMacosDeploymentTarget(value) {
	const minimum = JSON.parse(
		readFileSync(
			path.join(desktopDirectory, "src-tauri/tauri.conf.json"),
			"utf8",
		),
	).bundle.macOS.minimumSystemVersion;
	const target = value || minimum;
	const parseVersion = (version) => {
		if (typeof version !== "string" || !/^\d+(?:\.\d+){0,2}$/.test(version)) {
			throw new Error(`Invalid macOS deployment target: ${version}`);
		}
		const parts = version.split(".").map(Number);
		if (!parts.every(Number.isSafeInteger)) {
			throw new Error(`Invalid macOS deployment target: ${version}`);
		}
		return parts;
	};
	const required = parseVersion(minimum);
	const requested = parseVersion(target);
	for (let index = 0; index < 3; index++) {
		const difference = (requested[index] ?? 0) - (required[index] ?? 0);
		if (difference > 0) return target;
		if (difference < 0) {
			throw new Error(
				`MACOSX_DEPLOYMENT_TARGET=${target} is below Cap's minimum macOS version ${minimum}; ScreenCaptureKit requires macOS 12.3 or later.`,
			);
		}
	}
	return target;
}

export function isTimestampSigningFailure(output) {
	const lines = stripVTControlCharacters(output)
		.split(/\r?\n/)
		.map((line) => line.trim())
		.filter(
			(line) =>
				line &&
				!/^ELIFECYCLE\s+Command failed with exit code \d+\.$/.test(line) &&
				!/^error: script "[^"]+" exited with code \d+$/.test(line),
		);
	const signingError =
		/^(?:Error\s+)?failed to bundle project: failed to sign app$/;
	if (!signingError.test(lines.pop() ?? "")) return false;
	while (signingError.test(lines.at(-1) ?? "")) lines.pop();
	return /^\/.+: (?:A timestamp was expected but was not found|The timestamp service is not available)\.$/.test(
		lines.at(-1) ?? "",
	);
}

function validateArguments(target, args, platform) {
	let valid =
		platform === "darwin" &&
		/^(?:aarch64|x86_64)-apple-darwin$/.test(target ?? "");
	for (let index = 0; index < args.length && valid; index++) {
		const argument = args[index];
		if (
			argument === "--config" ||
			argument === "-c" ||
			argument === "--bundles" ||
			argument === "-b"
		) {
			const value = args[++index];
			valid = Boolean(value) && !value.startsWith("-");
		} else {
			valid =
				/^--(?:config|bundles)=.+/.test(argument) ||
				argument === "--verbose" ||
				/^-v{1,2}$/.test(argument);
		}
	}
	if (!valid) {
		throw new Error(
			"Run on macOS: node scripts/build-macos-packages.mjs <aarch64|x86_64>-apple-darwin [--config <path>] [--verbose]",
		);
	}
}

export function executeMacosCommand(
	args,
	{ env, signal, onOutput, spawnProcess = spawn, killProcess = process.kill },
) {
	signal?.throwIfAborted();
	return new Promise((resolve, reject) => {
		const child = spawnProcess("bun", ["run", ...args], {
			cwd: desktopDirectory,
			env,
			detached: true,
			stdio: ["ignore", "pipe", "pipe"],
		});
		let commandError;
		let killTimer;
		const terminate = (name) => {
			if (!child.pid) return;
			try {
				killProcess(-child.pid, name);
			} catch (error) {
				if (error.code !== "ESRCH") {
					commandError ??= error;
					child.kill(name);
				}
			}
		};
		const cancel = () => {
			terminate(signal.reason === "SIGINT" ? "SIGINT" : "SIGTERM");
			killTimer = setTimeout(() => terminate("SIGKILL"), 5_000);
			killTimer.unref();
		};
		for (const stream of ["stdout", "stderr"]) {
			child[stream].setEncoding("utf8");
			child[stream].on("data", (chunk) => onOutput(stream, chunk));
		}
		child.once("error", (error) => {
			commandError = error;
		});
		child.once("exit", (_code, childSignal) => {
			if (childSignal) terminate("SIGKILL");
		});
		child.once("close", (code, childSignal) => {
			signal?.removeEventListener("abort", cancel);
			clearTimeout(killTimer);
			if (signal?.aborted) {
				terminate("SIGKILL");
				reject(signal.reason);
			} else if (commandError) {
				reject(commandError);
			} else {
				resolve({ code, signal: childSignal });
			}
		});
		signal?.addEventListener("abort", cancel, { once: true });
		if (signal?.aborted) cancel();
	});
}

export async function buildMacosPackages(
	target,
	args = [],
	{
		bundleOnly = false,
		platform = process.platform,
		env = process.env,
		signal,
		execute = executeMacosCommand,
		delay = (milliseconds, abortSignal) =>
			wait(milliseconds, undefined, { signal: abortSignal }),
		onOutput = (stream, chunk) => process[stream].write(chunk),
	} = {},
) {
	validateArguments(target, args, platform);
	const commandArguments = ["--target", target, ...args];
	const environment = {
		...env,
		RUST_TARGET_TRIPLE: target,
		MACOSX_DEPLOYMENT_TARGET: resolveMacosDeploymentTarget(
			env.MACOSX_DEPLOYMENT_TARGET,
		),
	};
	commandArguments.push(
		"--config",
		JSON.stringify({
			bundle: {
				macOS: {
					minimumSystemVersion: environment.MACOSX_DEPLOYMENT_TARGET,
				},
			},
		}),
	);
	for (let attempt = 0; ; attempt++) {
		signal?.throwIfAborted();
		let outputTail = "";
		const command =
			attempt === 0 && !bundleOnly
				? ["build:tauri", ...commandArguments]
				: [
						"dotenv",
						"-e",
						"../../.env",
						"--",
						"bun",
						"run",
						"tauri",
						"bundle",
						...commandArguments,
					];
		const result = await execute(command, {
			env: environment,
			signal,
			onOutput: (stream, chunk) => {
				outputTail = (outputTail + chunk).slice(-outputTailLimit);
				onOutput(stream, chunk);
			},
		});
		signal?.throwIfAborted();
		if (result.error) throw result.error;
		if (
			!Number.isInteger(result.code) ||
			result.code <= 0 ||
			result.code >= 128 ||
			result.signal ||
			attempt === retryDelays.length ||
			!isTimestampSigningFailure(outputTail)
		) {
			return result;
		}
		onOutput(
			"stderr",
			`Secure timestamp signing failed; retrying macOS packaging in ${retryDelays[attempt] / 1_000}s (${attempt + 1}/${retryDelays.length}).\n`,
		);
		await delay(retryDelays[attempt], signal);
	}
}

async function main() {
	const [target, ...args] = process.argv.slice(2);
	if (target === "--deployment-target" && args.length === 0) {
		console.log(
			resolveMacosDeploymentTarget(process.env.MACOSX_DEPLOYMENT_TARGET),
		);
		return;
	}
	const controller = new AbortController();
	const interrupt = () => controller.abort("SIGINT");
	const terminate = () => controller.abort("SIGTERM");
	process.on("SIGINT", interrupt);
	process.on("SIGTERM", terminate);
	try {
		const result = await buildMacosPackages(target, args, {
			signal: controller.signal,
		});
		process.exitCode = result.signal
			? 128 + (constants.signals[result.signal] ?? 1)
			: (result.code ?? 1);
	} catch (error) {
		if (!controller.signal.aborted) throw error;
		process.exitCode = 128 + constants.signals[controller.signal.reason];
	} finally {
		process.removeListener("SIGINT", interrupt);
		process.removeListener("SIGTERM", terminate);
	}
}

if (
	process.argv[1] &&
	path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
) {
	main().catch((error) => {
		console.error(error?.message ?? error);
		process.exitCode = 1;
	});
}