@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/platforms/electrobun/scripts/local-adhoc-sign-macos.ts

@@ -0,0 +1,214 @@
+#!/usr/bin/env bun
+
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+type ExecFileSyncFn = typeof execFileSync;
+type SpawnSyncFn = typeof spawnSync;
+type EntitlementValue = boolean | string | string[];
+
+function escapePlistString(value: string): string {
+	return value
+		.replaceAll("&", "&")
+		.replaceAll("<", "&lt;")
+		.replaceAll(">", "&gt;")
+		.replaceAll('"', "&quot;")
+		.replaceAll("'", "&apos;");
+}
+
+function renderPlistValue(value: EntitlementValue): string {
+	if (typeof value === "boolean") {
+		return value ? "<true/>" : "<false/>";
+	}
+	if (Array.isArray(value)) {
+		const entries = value
+			.map((item) => `    <string>${escapePlistString(item)}</string>`)
+			.join("\n");
+		return `<array>\n${entries}\n  </array>`;
+	}
+	return `<string>${escapePlistString(value)}</string>`;
+}
+
+export function createEntitlementsPlist(
+	entitlements: Record<string, EntitlementValue>,
+): string {
+	const entries = Object.entries(entitlements)
+		.sort(([left], [right]) => left.localeCompare(right))
+		.map(
+			([key, value]) =>
+				`  <key>${escapePlistString(key)}</key>\n  ${renderPlistValue(value)}`,
+		)
+		.join("\n");
+
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+${entries}
+</dict>
+</plist>
+`;
+}
+
+export function parseCodesignIdentifier(output: string): string | null {
+	const match = output.match(/^Identifier=(.+)$/m);
+	return match?.[1]?.trim() ?? null;
+}
+
+export function shouldApplyLocalAdhocSigning(
+	env: NodeJS.ProcessEnv = process.env,
+): boolean {
+	return process.platform === "darwin" && env.ELECTROBUN_SKIP_CODESIGN === "1";
+}
+
+function readCodesignOutput(
+	targetPath: string,
+	spawnFile: SpawnSyncFn,
+): string {
+	const result = spawnFile("codesign", ["-dv", "--verbose=4", targetPath], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+
+	if (result.error) {
+		throw result.error;
+	}
+	if (result.status !== 0) {
+		throw new Error(
+			`[local-sign] failed to inspect ${targetPath}: ${result.stderr || result.stdout || "unknown codesign error"}`,
+		);
+	}
+
+	return `${result.stdout ?? ""}${result.stderr ?? ""}`;
+}
+
+function runCodesign(
+	targetPath: string,
+	entitlementsPath: string,
+	expectedIdentifier: string,
+	execFile: ExecFileSyncFn,
+): void {
+	execFile(
+		"codesign",
+		[
+			"--force",
+			"--sign",
+			"-",
+			"--identifier",
+			expectedIdentifier,
+			"--options",
+			"runtime",
+			"--entitlements",
+			entitlementsPath,
+			targetPath,
+		],
+		{
+			stdio: ["ignore", "pipe", "pipe"],
+		},
+	);
+}
+
+export function collectMacCodeSignTargets(appBundlePath: string): string[] {
+	const binaryDir = path.join(appBundlePath, "Contents", "MacOS");
+	return [
+		path.join(binaryDir, "libNativeWrapper.dylib"),
+		path.join(binaryDir, "libwebgpu_dawn.dylib"),
+		path.join(binaryDir, "libasar.dylib"),
+		path.join(binaryDir, "bun"),
+		path.join(binaryDir, "extractor"),
+		path.join(binaryDir, "process_helper"),
+		path.join(binaryDir, "zig-zstd"),
+		path.join(binaryDir, "zig-asar"),
+		path.join(binaryDir, "bspatch"),
+		path.join(binaryDir, "bsdiff"),
+		path.join(binaryDir, "launcher"),
+		appBundlePath,
+	].filter((target, index, targets) => targets.indexOf(target) === index);
+}
+
+export function signLocalAppBundle(args: {
+	appBundlePath: string;
+	entitlements: Record<string, EntitlementValue>;
+	expectedIdentifier: string;
+	execFile?: ExecFileSyncFn;
+	spawnFile?: SpawnSyncFn;
+}): void {
+	const execFile = args.execFile ?? execFileSync;
+	const spawnFile = args.spawnFile ?? spawnSync;
+	const appBundlePath = path.resolve(args.appBundlePath);
+	const launcherPath = path.join(
+		appBundlePath,
+		"Contents",
+		"MacOS",
+		"launcher",
+	);
+
+	if (!fs.existsSync(appBundlePath)) {
+		throw new Error(`[local-sign] app bundle not found: ${appBundlePath}`);
+	}
+	if (!fs.existsSync(launcherPath)) {
+		throw new Error(`[local-sign] launcher not found: ${launcherPath}`);
+	}
+
+	const entitlementsPath = path.join(
+		os.tmpdir(),
+		`elizaos-local-entitlements-${process.pid}-${Date.now()}.plist`,
+	);
+
+	fs.writeFileSync(
+		entitlementsPath,
+		createEntitlementsPlist(args.entitlements),
+		"utf8",
+	);
+
+	try {
+		const signTargets = collectMacCodeSignTargets(appBundlePath).filter(
+			(target) => fs.existsSync(target),
+		);
+
+		for (const target of signTargets) {
+			runCodesign(target, entitlementsPath, args.expectedIdentifier, execFile);
+		}
+
+		for (const target of signTargets) {
+			const codesignOutput = readCodesignOutput(target, spawnFile);
+			const identifier = parseCodesignIdentifier(codesignOutput);
+			if (identifier !== args.expectedIdentifier) {
+				throw new Error(
+					`[local-sign] expected ${target} identifier ${args.expectedIdentifier}, got ${identifier ?? "unknown"}`,
+				);
+			}
+		}
+	} finally {
+		fs.rmSync(entitlementsPath, { force: true });
+	}
+}
+
+async function main(): Promise<void> {
+	const appBundlePath = process.argv[2];
+	if (!appBundlePath) {
+		throw new Error(
+			"Usage: bun scripts/local-adhoc-sign-macos.ts /path/to/the app.app",
+		);
+	}
+
+	const electrobunConfig = (await import("../electrobun.config")).default;
+	const entitlements = electrobunConfig.build?.mac?.entitlements;
+	if (!entitlements) {
+		throw new Error(
+			"[local-sign] missing macOS entitlements in Electrobun config",
+		);
+	}
+	signLocalAppBundle({
+		appBundlePath,
+		entitlements,
+		expectedIdentifier: electrobunConfig.app.identifier,
+	});
+	console.log(`[local-sign] signed ${path.resolve(appBundlePath)}`);
+}
+
+if (import.meta.main) {
+	await main();
+}

package/platforms/electrobun/scripts/macos-direct-launcher.c

@@ -0,0 +1,84 @@
+#include <errno.h>
+#include <limits.h>
+#include <mach-o/dyld.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static int fail(const char *message) {
+  fprintf(stderr, "%s: %s\n", message, strerror(errno));
+  return 111;
+}
+
+int main(void) {
+  uint32_t executable_path_size = 0;
+  _NSGetExecutablePath(NULL, &executable_path_size);
+
+  char *executable_path = malloc((size_t)executable_path_size + 1U);
+  if (executable_path == NULL) {
+    fputs("failed to allocate executable path buffer\n", stderr);
+    return 111;
+  }
+
+  if (_NSGetExecutablePath(executable_path, &executable_path_size) != 0) {
+    free(executable_path);
+    fputs("failed to resolve executable path\n", stderr);
+    return 111;
+  }
+
+  char resolved_path[PATH_MAX];
+  if (realpath(executable_path, resolved_path) == NULL) {
+    free(executable_path);
+    return fail("failed to canonicalize executable path");
+  }
+  free(executable_path);
+
+  char *last_slash = strrchr(resolved_path, '/');
+  if (last_slash == NULL) {
+    fputs("unexpected executable path format\n", stderr);
+    return 111;
+  }
+  *last_slash = '\0';
+
+  if (chdir(resolved_path) != 0) {
+    return fail("failed to change into launcher directory");
+  }
+
+  size_t bun_path_size = strlen(resolved_path) + strlen("/bun") + 1U;
+  char *bun_path = malloc(bun_path_size);
+  if (bun_path == NULL) {
+    fputs("failed to allocate bun path buffer\n", stderr);
+    return 111;
+  }
+  if (snprintf(bun_path, bun_path_size, "%s/bun", resolved_path) < 0) {
+    free(bun_path);
+    fputs("failed to format bun path\n", stderr);
+    return 111;
+  }
+
+  size_t main_js_path_size =
+      strlen(resolved_path) + strlen("/../Resources/main.js") + 1U;
+  char *main_js_path = malloc(main_js_path_size);
+  if (main_js_path == NULL) {
+    free(bun_path);
+    fputs("failed to allocate main.js path buffer\n", stderr);
+    return 111;
+  }
+  if (snprintf(
+          main_js_path,
+          main_js_path_size,
+          "%s/../Resources/main.js",
+          resolved_path) < 0) {
+    free(main_js_path);
+    free(bun_path);
+    fputs("failed to format main.js path\n", stderr);
+    return 111;
+  }
+
+  char *const child_argv[] = {bun_path, main_js_path, NULL};
+  execv(child_argv[0], child_argv);
+  free(main_js_path);
+  free(bun_path);
+  return fail("failed to exec bundled bun runtime");
+}

package/platforms/electrobun/scripts/postwrap-diagnostics.ts

@@ -0,0 +1,423 @@
+#!/usr/bin/env bun
+
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import electrobunConfig from "../electrobun.config";
+import {
+	shouldApplyLocalAdhocSigning,
+	signLocalAppBundle,
+} from "./local-adhoc-sign-macos";
+
+type BinaryReport = {
+	exists: boolean;
+	name: string;
+	path: string;
+	codesign?: string;
+	file?: string;
+	lipo?: string;
+};
+
+type ArchiveReport = {
+	containsWgpuDawn: boolean;
+	path: string;
+	sampleEntries: string[];
+};
+
+type WrapperDiagnostics = {
+	appName: string;
+	arch: string;
+	binaryDir: string;
+	binaries: BinaryReport[];
+	buildDir: string | null;
+	generatedAt: string;
+	os: string;
+	outputPath: string;
+	resourcesDir: string;
+	resourceArchives: ArchiveReport[];
+	wrapperBundlePath: string;
+};
+
+const WINDOWS_ABS_PATH_RE = /^[A-Za-z]:[\\/]/;
+const RUNTIME_BINARY_NAMES: Record<string, string[]> = {
+	linux: [
+		"bun",
+		"libwebgpu_dawn.so",
+		"libNativeWrapper.so",
+		"bspatch",
+		"extractor",
+		"process_helper",
+		"libasar.so",
+	],
+	macos: [
+		"bun",
+		"libwebgpu_dawn.dylib",
+		"libNativeWrapper.dylib",
+		"zig-zstd",
+		"bspatch",
+		"extractor",
+		"process_helper",
+		"zig-asar",
+		"bsdiff",
+		"libasar.dylib",
+	],
+	win: [
+		"bun.exe",
+		"libwebgpu_dawn.dll",
+		"bspatch.exe",
+		"extractor.exe",
+		"process_helper.exe",
+		"libNativeWrapper.dll",
+	],
+};
+
+function isPosixAbsolutePath(value: string): boolean {
+	return value.startsWith("/") && !WINDOWS_ABS_PATH_RE.test(value);
+}
+
+function resolvePortablePath(value: string): string {
+	return isPosixAbsolutePath(value) || WINDOWS_ABS_PATH_RE.test(value)
+		? value
+		: path.resolve(value);
+}
+
+function joinPortable(base: string, ...parts: string[]): string {
+	return isPosixAbsolutePath(base)
+		? path.posix.join(base, ...parts)
+		: path.join(base, ...parts);
+}
+
+function dirnamePortable(value: string): string {
+	return isPosixAbsolutePath(value)
+		? path.posix.dirname(value)
+		: path.dirname(value);
+}
+
+function execText(command: string, args: string[]): string {
+	return execFileSync(command, args, {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "pipe"],
+	}).trim();
+}
+
+export function resolveRequiredRuntimeBinaryNames(osName: string): string[] {
+	return RUNTIME_BINARY_NAMES[osName] ?? [];
+}
+
+function resolveElectrobunRuntimeDir(osName: string, arch: string): string {
+	const packageRoot = path.resolve(
+		fileURLToPath(new URL("..", import.meta.url)),
+		"node_modules",
+		"electrobun",
+	);
+	const runtimeDirName =
+		osName === "macos"
+			? `dist-macos-${arch}`
+			: osName === "win"
+				? `dist-win-${arch}`
+				: `dist-linux-${arch}`;
+	return joinPortable(packageRoot, runtimeDirName);
+}
+
+function copyFileWithMode(sourcePath: string, destinationPath: string): void {
+	fs.mkdirSync(dirnamePortable(destinationPath), { recursive: true });
+	fs.copyFileSync(sourcePath, destinationPath);
+	const sourceMode = fs.statSync(sourcePath).mode;
+	fs.chmodSync(destinationPath, sourceMode);
+}
+
+export function ensureWrapperRuntimeFiles(args: {
+	arch: string;
+	binaryDir: string;
+	osName: string;
+}): string[] {
+	const runtimeDir = resolveElectrobunRuntimeDir(args.osName, args.arch);
+	if (!fs.existsSync(runtimeDir)) {
+		return [];
+	}
+
+	const copied: string[] = [];
+	for (const fileName of resolveRequiredRuntimeBinaryNames(args.osName)) {
+		const sourcePath = joinPortable(runtimeDir, fileName);
+		const destinationPath = joinPortable(args.binaryDir, fileName);
+		if (!fs.existsSync(sourcePath) || fs.existsSync(destinationPath)) {
+			continue;
+		}
+		copyFileWithMode(sourcePath, destinationPath);
+		copied.push(fileName);
+	}
+	return copied;
+}
+
+function normalizeBundleStem(value: string): string {
+	return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function resolveBuildBundlePath(env: NodeJS.ProcessEnv): string | null {
+	const buildDir = env.ELECTROBUN_BUILD_DIR?.trim();
+	if (!buildDir) {
+		return null;
+	}
+
+	const resolvedBuildDir = path.resolve(buildDir);
+	if (!fs.existsSync(resolvedBuildDir)) {
+		return null;
+	}
+
+	const bundleCandidates = fs
+		.readdirSync(resolvedBuildDir, { withFileTypes: true })
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => joinPortable(resolvedBuildDir, entry.name));
+
+	if (bundleCandidates.length === 0) {
+		return null;
+	}
+
+	const wrapperPath = env.ELECTROBUN_WRAPPER_BUNDLE_PATH?.trim();
+	if (wrapperPath) {
+		const resolvedWrapperPath = resolvePortablePath(wrapperPath);
+		if (fs.existsSync(resolvedWrapperPath)) {
+			return resolvedWrapperPath;
+		}
+	}
+
+	const appName = env.ELECTROBUN_APP_NAME?.trim();
+	if (appName) {
+		const normalizedAppName = normalizeBundleStem(appName);
+		const matched = bundleCandidates.find((candidate) => {
+			const stem = path.basename(candidate, path.extname(candidate));
+			return normalizeBundleStem(stem) === normalizedAppName;
+		});
+		if (matched) {
+			return matched;
+		}
+	}
+
+	if (bundleCandidates.length === 1) {
+		return bundleCandidates[0] ?? null;
+	}
+
+	return null;
+}
+
+export function resolveWrapperBundlePath(
+	args = process.argv.slice(2),
+	env: NodeJS.ProcessEnv = process.env,
+): string {
+	const explicitPath = args.find((arg) => arg.trim().length > 0);
+	if (explicitPath) {
+		return resolvePortablePath(explicitPath);
+	}
+
+	const wrapperBundlePath = env.ELECTROBUN_WRAPPER_BUNDLE_PATH?.trim();
+	if (wrapperBundlePath) {
+		return resolvePortablePath(wrapperBundlePath);
+	}
+
+	const buildBundlePath = resolveBuildBundlePath(env);
+	if (buildBundlePath) {
+		return buildBundlePath;
+	}
+
+	throw new Error(
+		"postwrap-diagnostics: wrapper bundle path not provided and Electrobun did not expose one",
+	);
+}
+
+export function resolveBundleLayout(
+	bundlePath: string,
+	osName: string,
+): { binaryDir: string; resourcesDir: string } {
+	if (osName === "macos") {
+		return {
+			binaryDir: joinPortable(bundlePath, "Contents", "MacOS"),
+			resourcesDir: joinPortable(bundlePath, "Contents", "Resources"),
+		};
+	}
+
+	return {
+		binaryDir: joinPortable(bundlePath, "bin"),
+		resourcesDir: joinPortable(bundlePath, "resources"),
+	};
+}
+
+export function resolveDiagnosticsOutputPath(
+	bundlePath: string,
+	env: NodeJS.ProcessEnv = process.env,
+): string {
+	const buildDir = env.ELECTROBUN_BUILD_DIR?.trim();
+	if (buildDir) {
+		const resolvedBuildDir = resolvePortablePath(buildDir);
+		return joinPortable(resolvedBuildDir, "wrapper-diagnostics.json");
+	}
+	return joinPortable(dirnamePortable(bundlePath), "wrapper-diagnostics.json");
+}
+
+function collectBinaryReport(
+	binaryDir: string,
+	fileName: string,
+): BinaryReport {
+	const filePath = joinPortable(binaryDir, fileName);
+	if (!fs.existsSync(filePath)) {
+		return {
+			exists: false,
+			name: fileName,
+			path: filePath,
+		};
+	}
+
+	const report: BinaryReport = {
+		exists: true,
+		name: fileName,
+		path: filePath,
+	};
+
+	try {
+		report.file = execText("file", ["-b", filePath]);
+	} catch (error) {
+		report.file = `file failed: ${(error as Error).message}`;
+	}
+
+	try {
+		report.lipo = execText("lipo", ["-info", filePath]);
+	} catch {
+		// Not all files support lipo -info.
+	}
+
+	if (process.platform === "darwin") {
+		try {
+			report.codesign = execText("codesign", ["-dv", "--verbose=2", filePath]);
+		} catch (error) {
+			report.codesign = `codesign failed: ${(error as Error).message}`;
+		}
+	}
+
+	return report;
+}
+
+function collectArchiveReports(resourcesDir: string): ArchiveReport[] {
+	if (!fs.existsSync(resourcesDir)) {
+		return [];
+	}
+
+	return fs
+		.readdirSync(resourcesDir)
+		.filter((entry) => entry.endsWith(".tar.zst"))
+		.map((entry) => joinPortable(resourcesDir, entry))
+		.sort()
+		.map((archivePath) => {
+			let sampleEntries: string[] = [];
+			try {
+				const listing = execText("tar", ["--zstd", "-tf", archivePath]);
+				sampleEntries = listing
+					.split("\n")
+					.map((line) => line.trim())
+					.filter(Boolean)
+					.slice(0, 20);
+				return {
+					containsWgpuDawn: listing.includes("libwebgpu_dawn"),
+					path: archivePath,
+					sampleEntries,
+				};
+			} catch (error) {
+				return {
+					containsWgpuDawn: false,
+					path: archivePath,
+					sampleEntries: [`tar listing failed: ${(error as Error).message}`],
+				};
+			}
+		});
+}
+
+export function main(
+	args = process.argv.slice(2),
+	env: NodeJS.ProcessEnv = process.env,
+): void {
+	const osName = env.ELECTROBUN_OS?.trim() || process.platform;
+	const arch = env.ELECTROBUN_ARCH?.trim() || process.arch;
+	const wrapperBundlePath = resolveWrapperBundlePath(args, env);
+	const { binaryDir, resourcesDir } = resolveBundleLayout(
+		wrapperBundlePath,
+		osName,
+	);
+	const outputPath = resolveDiagnosticsOutputPath(wrapperBundlePath, env);
+
+	const repairedFiles = ensureWrapperRuntimeFiles({
+		arch,
+		binaryDir,
+		osName,
+	});
+	if (repairedFiles.length > 0) {
+		console.log(
+			`[postwrap-diagnostics] restored wrapper runtime files: ${repairedFiles.join(", ")}`,
+		);
+	}
+
+	if (shouldApplyLocalAdhocSigning(env)) {
+		const entitlements = electrobunConfig.build?.mac?.entitlements;
+		if (!entitlements) {
+			throw new Error(
+				"[postwrap-diagnostics] missing macOS entitlements in Electrobun config",
+			);
+		}
+		signLocalAppBundle({
+			appBundlePath: wrapperBundlePath,
+			entitlements,
+			expectedIdentifier: electrobunConfig.app.identifier,
+		});
+		console.log(
+			`[postwrap-diagnostics] applied local ad-hoc signing for ${wrapperBundlePath}`,
+		);
+	}
+
+	const binaryNames = [
+		osName === "win" ? "launcher.exe" : "launcher",
+		...resolveRequiredRuntimeBinaryNames(osName),
+	];
+
+	const diagnostics: WrapperDiagnostics = {
+		appName:
+			env.ELECTROBUN_APP_NAME?.trim() || path.basename(wrapperBundlePath),
+		arch,
+		binaryDir,
+		binaries: binaryNames.map((binaryName) =>
+			collectBinaryReport(binaryDir, binaryName),
+		),
+		buildDir: env.ELECTROBUN_BUILD_DIR?.trim() || null,
+		generatedAt: new Date().toISOString(),
+		os: osName,
+		outputPath,
+		resourcesDir,
+		resourceArchives: collectArchiveReports(resourcesDir),
+		wrapperBundlePath,
+	};
+
+	fs.mkdirSync(dirnamePortable(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, `${JSON.stringify(diagnostics, null, 2)}\n`);
+
+	console.log(
+		`[postwrap-diagnostics] wrote ${outputPath} (${diagnostics.os}/${diagnostics.arch})`,
+	);
+	for (const binary of diagnostics.binaries) {
+		if (!binary.exists) {
+			console.log(`[postwrap-diagnostics] missing ${binary.name}`);
+			continue;
+		}
+		const summary = [binary.file, binary.lipo].filter(Boolean).join(" | ");
+		console.log(`[postwrap-diagnostics] ${binary.name}: ${summary}`);
+	}
+	for (const archive of diagnostics.resourceArchives) {
+		console.log(
+			`[postwrap-diagnostics] archive ${path.basename(archive.path)} contains libwebgpu_dawn=${archive.containsWgpuDawn}`,
+		);
+	}
+}
+
+if (
+	process.argv[1] &&
+	path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+) {
+	main();
+}