sparkbun 0.1.8 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sparkbun",
-	"version": "0.1.8",
+	"version": "0.2.0",
 	"description": "Build fast, lightweight, cross-platform desktop apps with TypeScript and Bun.",
 	"license": "MIT",
 	"author": "SparkBun Contributors",

package/src/cli/index.ts

@@ -76,7 +76,7 @@ const commandArg = process.argv[indexOfCli + 1] || "build";
 // Walk up from projectRoot to find electrobun in node_modules (supports hoisted monorepo layouts)
 function resolveSparkBunDir(): string {
 	// When running from SparkBun source (src/cli/index.ts), the package root is two levels up
-	const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+	const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 	const sourcePackageDir = join(cliDir, "..", "..");
 	if (existsSync(join(sourcePackageDir, "package.json")) && existsSync(join(sourcePackageDir, "src", "cli"))) {
 		return sourcePackageDir;
@@ -1663,6 +1663,17 @@ ${utiDecls}
 			}
 			await runAppWithSignalHandling(config);
 		}
+	} else if (commandArg === "installer") {
+		const config = await getConfig();
+		const envArg =
+			process.argv.find((arg) => arg.startsWith("--env="))?.split("=")[1] || "";
+		const buildEnvironment: "dev" | "stable" = envArg === "dev" ? "dev" : "stable";
+		try {
+			await runInstallerBuild(config, buildEnvironment);
+		} catch (error) {
+			console.error("Installer build failed:", error);
+			process.exit(1);
+		}
 	}
 
 	async function runBuild(
@@ -2067,7 +2078,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 
 		// Compile launcher from source using Bun.build() API
-		const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 		const sparkbunRoot = join(cliDir, "..", "..");
 		const launcherSourcePath = join(sparkbunRoot, "src", "launcher", "main.ts");
 		const bunTarget = `bun-${targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux"}-${currentTarget.arch}` as const;
@@ -3187,6 +3198,387 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		// stapler validate -v <app path>
 	}
 
+	async function runInstallerBuild(
+		config: Awaited<ReturnType<typeof getConfig>>,
+		buildEnvironment: "dev" | "stable",
+	) {
+		// --- Parse installer-specific CLI flags ---
+
+		const archives: { name: string; path: string }[] = [];
+		for (let i = 0; i < process.argv.length; i++) {
+			if (process.argv[i] === "--archive" && process.argv[i + 1]) {
+				const arg = process.argv[i + 1]!;
+				const eqIdx = arg.indexOf("=");
+				if (eqIdx === -1) {
+					console.error(`Invalid --archive format: "${arg}". Expected: name=path`);
+					process.exit(1);
+				}
+				const name = arg.substring(0, eqIdx);
+				const archivePath = arg.substring(eqIdx + 1);
+				if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+					console.error(`Invalid archive name: "${name}". Must be a valid identifier ([a-zA-Z_][a-zA-Z0-9_]*).`);
+					process.exit(1);
+				}
+				if (archives.some((a) => a.name === name)) {
+					console.error(`Duplicate archive name: "${name}".`);
+					process.exit(1);
+				}
+				const resolvedPath = path.resolve(projectRoot, archivePath);
+				if (!existsSync(resolvedPath)) {
+					console.error(`Archive path does not exist: ${resolvedPath}`);
+					process.exit(1);
+				}
+				archives.push({ name, path: resolvedPath });
+			}
+		}
+
+		const getFlag = (prefix: string): string | undefined =>
+			process.argv.find((arg) => arg.startsWith(prefix))?.split("=").slice(1).join("=");
+
+		const outPath = getFlag("--out=");
+		const iconPath = getFlag("--icon=");
+		const installerName = getFlag("--name=") || config.app.name;
+		const installerVersion = getFlag("--version=") || config.app.version;
+		const installerPublisher = getFlag("--publisher=") || (config.app as any).publisher || "";
+		const metadataPath = getFlag("--metadata=");
+
+		// Determine target platform
+		const targetArg = getFlag("--target=");
+		let targetOS: "macos" | "win" | "linux" = OS;
+		let targetARCH: "arm64" | "x64" = ARCH;
+		if (targetArg) {
+			const [tOS, tArch] = targetArg.split("-") as [string, string];
+			const osMap: Record<string, "macos" | "win" | "linux"> = { macos: "macos", darwin: "macos", win: "win", windows: "win", linux: "linux" };
+			const archMap: Record<string, "arm64" | "x64"> = { arm64: "arm64", aarch64: "arm64", x64: "x64", x86_64: "x64" };
+			if (osMap[tOS] && archMap[tArch]) {
+				targetOS = osMap[tOS];
+				targetARCH = archMap[tArch];
+				console.log(`Cross-compiling installer for ${targetOS}-${targetARCH}`);
+			} else {
+				console.error(`Invalid target: ${targetArg}. Use format: win-x64, linux-arm64, macos-arm64`);
+				process.exit(1);
+			}
+		}
+
+		const targetBinExt = targetOS === "win" ? ".exe" : "";
+
+		console.log(`Building installer: ${installerName} v${installerVersion}`);
+		if (archives.length > 0) {
+			console.log(`Archives: ${archives.map((a) => `${a.name}=${a.path}`).join(", ")}`);
+		}
+
+		// --- Ensure native dependencies ---
+
+		await ensureCoreDependencies(targetOS, targetARCH);
+		const targetPaths = getPlatformPaths(targetOS, targetARCH);
+
+		// --- Set up build folder ---
+
+		const platformPrefix = getPlatformPrefix(buildEnvironment, targetOS, targetARCH);
+		const buildFolder = join(projectRoot, config.build.buildFolder, `installer-${platformPrefix}`);
+
+		if (existsSync(buildFolder)) {
+			rmSync(buildFolder, { recursive: true, force: true });
+		}
+		mkdirSync(buildFolder, { recursive: true });
+
+		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
+		const sparkbunRoot = join(cliDir, "..", "..");
+		const bunTarget = `bun-${targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux"}-${targetARCH}` as const;
+		const targetOSName = targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux";
+		const isWindows = targetOS === "win";
+
+		// --- Create archives first (they go into the compiled binary, not the runtime bundle) ---
+
+		const stagingDir = join(buildFolder, ".installer-staging");
+		if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
+		mkdirSync(stagingDir, { recursive: true });
+
+		const archiveManifest: Record<string, string> = {};
+
+		if (archives.length > 0) {
+			console.log("Creating archives (LZMA solid via NSIS)...");
+
+			const nsisDir = join(SPARKBUN_DEP_PATH, `dist-${targetOS}-${targetARCH}`, "nsis");
+			const makensisPath = join(nsisDir, "Bin", "makensis.exe");
+			if (!existsSync(makensisPath)) {
+				throw new Error(`makensis not found at ${makensisPath}. LZMA compression requires NSIS binaries in dist-${targetOS}-${targetARCH}/nsis/`);
+			}
+
+			for (const { name, path: archiveSrcPath } of archives) {
+				const archiveFileName = `archive-${name}.exe`;
+				const archiveDestPath = join(stagingDir, archiveFileName);
+				const nsiPath = join(stagingDir, `archive-${name}.nsi`);
+
+				console.log(`  Archiving ${name}: ${archiveSrcPath}`);
+
+				const nsiContent = `SetCompressor /SOLID lzma\nSilentInstall silent\nName "${name}"\nOutFile "${archiveDestPath.replace(/\\/g, "\\\\")}"\nInstallDir "$TEMP\\sparkbun-extract-${name}"\nSection\n  SetOutPath "$INSTDIR"\n  File /r "${archiveSrcPath.replace(/\\/g, "\\\\")}\\*.*"\nSectionEnd\n`;
+				writeFileSync(nsiPath, nsiContent);
+
+				const result = Bun.spawnSync([makensisPath, nsiPath], {
+					cwd: nsisDir,
+					env: { ...process.env, NSISDIR: nsisDir },
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+
+				if (result.exitCode !== 0) {
+					const stderr = result.stderr.toString();
+					const stdout = result.stdout.toString();
+					console.error(`makensis failed for ${name}:`, stderr || stdout);
+					throw new Error(`Failed to compress archive: ${name}`);
+				}
+
+				unlinkSync(nsiPath);
+
+				const archiveSize = statSync(archiveDestPath).size;
+				console.log(`  ${name}: ${(archiveSize / 1024 / 1024).toFixed(2)} MB`);
+				archiveManifest[name] = archiveFileName;
+			}
+		}
+
+		// --- Build the runtime bundle (DLLs, views, app code — NO launcher binary, NO archives) ---
+
+		console.log("Building runtime bundle...");
+		const appFileName = getAppFileName(config.app.name, buildEnvironment);
+		const bundle = createAppBundle(appFileName, buildFolder, targetOS);
+		const appBundleFolderPath = bundle.appBundleFolderPath;
+		const appBundleMacOSPath = bundle.appBundleMacOSPath;
+		const appBundleFolderResourcesPath = bundle.appBundleFolderResourcesPath;
+		const appBundleAppCodePath = join(appBundleFolderResourcesPath, "app");
+		mkdirSync(appBundleAppCodePath, { recursive: true });
+		mkdirSync(appBundleMacOSPath, { recursive: true });
+
+		// Copy native wrappers
+		if (targetOS === "win") {
+			cpSync(targetPaths.CORE_WIN, join(appBundleMacOSPath, "SparkBunCore.dll"), { dereference: true });
+			cpSync(targetPaths.NATIVE_WRAPPER_WIN, join(appBundleMacOSPath, "libNativeWrapper.dll"), { dereference: true });
+			cpSync(targetPaths.WEBVIEW2LOADER_WIN, join(appBundleMacOSPath, "WebView2Loader.dll"), { dereference: true });
+		} else if (targetOS === "macos") {
+			cpSync(targetPaths.CORE_MACOS, join(appBundleMacOSPath, "libSparkBunCore.dylib"), { dereference: true });
+			cpSync(targetPaths.NATIVE_WRAPPER_MACOS, join(appBundleMacOSPath, "libNativeWrapper.dylib"), { dereference: true });
+		} else if (targetOS === "linux") {
+			cpSync(targetPaths.CORE_LINUX, join(appBundleMacOSPath, "libSparkBunCore.so"), { dereference: true });
+			cpSync(targetPaths.NATIVE_WRAPPER_LINUX, join(appBundleMacOSPath, "libNativeWrapper.so"), { dereference: true });
+		}
+
+		// libasar stub
+		const libExt = targetOS === "win" ? ".dll" : targetOS === "macos" ? ".dylib" : ".so";
+		const platformDistDir = join(SPARKBUN_DEP_PATH, `dist-${targetOS}-${targetARCH}`);
+		const asarLibSource = join(platformDistDir, "libasar" + libExt);
+		if (existsSync(asarLibSource)) {
+			cpSync(asarLibSource, join(appBundleMacOSPath, "libasar" + libExt), { dereference: true });
+		}
+
+		// Bundle bun code
+		const bunConfig = config.build.bun;
+		const bunSource = join(projectRoot, bunConfig.entrypoint);
+		if (!existsSync(bunSource)) {
+			throw new Error(`Bun entrypoint not found: ${bunSource}`);
+		}
+
+		const bunDestFolder = join(appBundleAppCodePath, "bun");
+		const { entrypoint: _bunEntrypoint, ...bunBuildOptions } = bunConfig;
+		const bunBuildResult = await Bun.build({
+			...bunBuildOptions,
+			entrypoints: [bunSource],
+			outdir: bunDestFolder,
+			target: "bun",
+		});
+		if (!bunBuildResult.success) {
+			console.error("Failed to build bun entrypoint:", bunSource);
+			printBuildLogs(bunBuildResult.logs);
+			throw new Error("Build failed: bun build failed");
+		}
+
+		// Bundle views
+		for (const viewName in config.build.views) {
+			const viewConfig = config.build.views[viewName]!;
+			const viewSource = join(projectRoot, viewConfig.entrypoint);
+			if (!existsSync(viewSource)) {
+				console.error(`View entrypoint not found: ${viewSource}`);
+				continue;
+			}
+
+			const viewDestFolder = join(appBundleAppCodePath, "views", viewName);
+			mkdirSync(viewDestFolder, { recursive: true });
+
+			const { entrypoint: _viewEntrypoint, ...viewBuildOptions } = viewConfig;
+			const viewBuildResult = await Bun.build({
+				...viewBuildOptions,
+				entrypoints: [viewSource],
+				outdir: viewDestFolder,
+				target: "browser",
+			});
+			if (!viewBuildResult.success) {
+				console.error("Failed to build view:", viewSource);
+				printBuildLogs(viewBuildResult.logs);
+			}
+		}
+
+		// Copy assets
+		for (const relSource in config.build.copy) {
+			const source = join(projectRoot, relSource);
+			if (!existsSync(source)) {
+				console.error(`Asset not found: ${source}`);
+				continue;
+			}
+
+			const destination = join(appBundleAppCodePath, config.build.copy[relSource]!);
+			const destFolder = dirname(destination);
+			if (!existsSync(destFolder)) {
+				mkdirSync(destFolder, { recursive: true });
+			}
+
+			cpSync(source, destination, { recursive: true, dereference: true });
+		}
+
+		// Write build.json
+		const buildJson = {
+			name: config.app.name,
+			identifier: config.app.identifier,
+			version: installerVersion,
+			channel: buildEnvironment,
+			...config.runtime,
+		};
+		await Bun.write(join(appBundleAppCodePath, "build.json"), JSON.stringify(buildJson, null, 2));
+
+		// Write archives.json manifest into runtime bundle so app code knows archive names
+		await Bun.write(
+			join(appBundleFolderResourcesPath, "archives.json"),
+			JSON.stringify(archiveManifest, null, 2),
+		);
+
+		// --- Create runtime bundle tar.gz (small — no launcher binary, no archives) ---
+
+		console.log("Packaging runtime bundle (gzip level 12)...");
+		const runtimeFiles: Record<string, ArrayBuffer> = {};
+		const bundleBase = basename(appBundleFolderPath);
+		async function walkBundle(dir: string, prefix: string) {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				const fullPath = join(dir, entry.name);
+				const archivePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					await walkBundle(fullPath, archivePath);
+				} else {
+					runtimeFiles[archivePath] = await Bun.file(fullPath).arrayBuffer();
+				}
+			}
+		}
+		await walkBundle(appBundleFolderPath, bundleBase);
+
+		const runtimeArchive = new Bun.Archive(runtimeFiles, { compress: "gzip", level: 12 });
+		const runtimeCompressedPath = join(buildFolder, `${appFileName}-runtime.tar.gz`);
+		await Bun.write(runtimeCompressedPath, await runtimeArchive.bytes());
+		rmSync(appBundleFolderPath, { recursive: true });
+
+		const runtimeSize = statSync(runtimeCompressedPath).size;
+		console.log(`  Runtime bundle: ${(runtimeSize / 1024 / 1024).toFixed(2)} MB`);
+
+		// --- Generate entrypoint and compile single installer exe ---
+
+		// Copy runtime bundle into staging
+		copyFileSync(runtimeCompressedPath, join(stagingDir, "runtime-bundle.tar.gz"));
+
+		// Write metadata
+		const metadata: Record<string, unknown> = {
+			name: installerName,
+			version: installerVersion,
+			identifier: config.app.identifier,
+			channel: buildEnvironment,
+			requireAdmin: (config.build?.win as any)?.requireAdmin || (config.build?.linux as any)?.requireAdmin || false,
+		};
+		if (metadataPath) {
+			const userMetadata = JSON.parse(readFileSync(path.resolve(projectRoot, metadataPath), "utf-8"));
+			Object.assign(metadata, userMetadata);
+		}
+		writeFileSync(join(stagingDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+
+		// Generate the entrypoint that imports the wrapper template + all archive files
+		// The wrapper template imports runtime-bundle.tar.gz and metadata.json.
+		// We generate an archives module that the app code can import at runtime.
+		const wrapperTemplatePath = join(cliDir, "..", "installer", "installer-wrapper-template.ts");
+		copyFileSync(wrapperTemplatePath, join(stagingDir, "installer.ts"));
+
+		// Generate archives.ts that embeds each archive via static imports
+		const archiveImports: string[] = [];
+		const archiveExports: string[] = [];
+		for (const { name } of archives) {
+			const fileName = archiveManifest[name];
+			archiveImports.push(`import archive_${name} from "./${fileName}" with { type: "file" };`);
+			archiveExports.push(`  "${name}": archive_${name},`);
+		}
+
+		const archivesModuleContent = `${archiveImports.join("\n")}
+
+export const embeddedArchives: Record<string, string> = {
+${archiveExports.join("\n")}
+};
+`;
+		writeFileSync(join(stagingDir, "embedded-archives.ts"), archivesModuleContent);
+
+		// --- Compile single installer exe ---
+
+		const defaultOutName = `${installerName.replace(/ /g, "-")}-Setup${targetBinExt}`;
+		const outputPath = outPath
+			? path.resolve(projectRoot, outPath)
+			: join(buildFolder, defaultOutName);
+
+		console.log("Compiling installer executable...");
+
+		const installerCompileOptions: any = {
+			target: `bun-${targetOSName}-${targetARCH}`,
+			outfile: outputPath,
+		};
+
+		if (isWindows && OS === "win") {
+			let icoPath: string | undefined;
+			if (iconPath) {
+				const resolvedIcon = path.resolve(projectRoot, iconPath);
+				if (existsSync(resolvedIcon)) {
+					icoPath = resolvedIcon;
+					if (resolvedIcon.toLowerCase().endsWith(".png")) {
+						const pngToIco = (await import("png-to-ico")).default;
+						const tempIcoPath = join(buildFolder, "temp-installer-icon.ico");
+						const icoBuffer = await pngToIco(resolvedIcon);
+						writeFileSync(tempIcoPath, new Uint8Array(icoBuffer));
+						icoPath = tempIcoPath;
+					}
+				}
+			}
+			installerCompileOptions.windows = {
+				hideConsole: true,
+				...(icoPath && { icon: icoPath }),
+				title: `${installerName} Setup`,
+				version: installerVersion,
+				description: `Installs ${installerName}`,
+				publisher: installerPublisher || " ",
+				copyright: (config.app as any).copyright || " ",
+			};
+		}
+
+		const installerBuild = await Bun.build({
+			entrypoints: [join(stagingDir, "installer.ts")],
+			compile: installerCompileOptions,
+		});
+		if (!installerBuild.success) {
+			console.error("Installer compilation failed:", installerBuild.logs);
+			throw new Error("Installer compilation failed");
+		}
+
+		if (isWindows) {
+			patchPeSubsystem(outputPath);
+		} else {
+			execSync(`chmod +x ${escapePathForTerminal(outputPath)}`);
+		}
+
+		// Clean up staging
+		rmSync(stagingDir, { recursive: true, force: true });
+
+		const exeSize = statSync(outputPath).size;
+		console.log(`\nInstaller built: ${outputPath} (${(exeSize / 1024 / 1024).toFixed(2)} MB)`);
+	}
+
 	// Take over as the terminal's foreground process group (macOS/Linux).
 	// This prevents the parent bun script runner from receiving SIGINT
 	// when Ctrl+C is pressed, keeping the terminal busy until the app
@@ -3827,7 +4219,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		writeFileSync(join(stagingDir, "metadata.json"), JSON.stringify(metadata, null, 2));
 
 		// Copy installer template
-		const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 		const templatePath = join(cliDir, "..", "installer", "installer-template.ts");
 		copyFileSync(templatePath, join(stagingDir, "installer.ts"));
 

package/src/installer/installer-wrapper-template.ts

@@ -0,0 +1,158 @@
+import runtimeArchive from "./runtime-bundle.tar.gz" with { type: "file" };
+import metadataJson from "./metadata.json" with { type: "file" };
+import { embeddedArchives } from "./embedded-archives";
+import { join, dirname, resolve } from "path";
+import { existsSync, mkdirSync, rmSync, readdirSync, writeFileSync } from "fs";
+import { dlopen, suffix, ptr } from "bun:ffi";
+
+interface Metadata {
+	name: string;
+	version?: string;
+	requireAdmin?: boolean;
+}
+
+const metadata: Metadata = await Bun.file(metadataJson).json();
+
+// Extract runtime files (DLLs, views, app code) to temp.
+// Archives stay embedded in this binary — extracted during install by the app code.
+const tempDir = join(
+	process.env.TEMP || process.env.TMP || process.env.LOCALAPPDATA || ".",
+	`.sparkbun-installer-${metadata.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+);
+
+try {
+	if (existsSync(tempDir)) {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+
+	const archiveBytes = await Bun.file(runtimeArchive).bytes();
+	const archive = new Bun.Archive(archiveBytes);
+	mkdirSync(tempDir, { recursive: true });
+	await archive.extract(tempDir);
+
+	// Find the bin directory inside the extracted bundle
+	let binDir = tempDir;
+	let bundleRoot = tempDir;
+	for (const entry of readdirSync(tempDir)) {
+		const entryPath = join(tempDir, entry);
+		if (existsSync(join(entryPath, "bin"))) {
+			binDir = join(entryPath, "bin");
+			bundleRoot = entryPath;
+			break;
+		}
+	}
+
+	// Write the embedded archive paths into the Resources directory so the app code can find them.
+	// Bun compile embeds files at virtual paths — we resolve them here and pass to the app.
+	const resourcesDir = join(bundleRoot, "Resources");
+	const archivePaths: Record<string, string> = {};
+	for (const [name, filePath] of Object.entries(embeddedArchives)) {
+		archivePaths[name] = filePath;
+	}
+	writeFileSync(
+		join(resourcesDir, "archive-paths.json"),
+		JSON.stringify(archivePaths, null, 2),
+	);
+
+	// Set CWD to bin dir so the launcher can find DLLs and ../Resources
+	process.chdir(binDir);
+
+	// --- Admin elevation check ---
+	if (metadata.requireAdmin && process.platform !== "darwin") {
+		const isAdmin = (): boolean => {
+			if (process.platform === "win32") {
+				const shell32 = dlopen("shell32.dll", {
+					IsUserAnAdmin: { args: [], returns: "bool" },
+				});
+				const admin = shell32.symbols.IsUserAnAdmin();
+				shell32.close();
+				return admin;
+			}
+			if (process.platform === "linux") {
+				return process.getuid?.() === 0;
+			}
+			return true;
+		};
+
+		if (!isAdmin()) {
+			if (process.platform === "win32") {
+				const shell32 = dlopen("shell32.dll", {
+					ShellExecuteW: {
+						args: ["ptr", "ptr", "ptr", "ptr", "ptr", "i32"],
+						returns: "ptr",
+					},
+				});
+				const encode = (s: string) => ptr(new Uint8Array(Buffer.from(s + "\0", "utf-16le")));
+				shell32.symbols.ShellExecuteW(
+					null,
+					encode("runas"),
+					encode(process.argv[0]),
+					null,
+					null,
+					1,
+				);
+				shell32.close();
+			} else if (process.platform === "linux") {
+				Bun.spawnSync(["pkexec", process.argv[0], ...process.argv.slice(1)], {
+					stdout: "inherit",
+					stderr: "inherit",
+				});
+			}
+			rmSync(tempDir, { recursive: true, force: true });
+			process.exit(0);
+		}
+	}
+
+	// --- Load SparkBunCore and run ---
+	const coreLibFileName =
+		process.platform === "win32"
+			? "SparkBunCore.dll"
+			: `libSparkBunCore.${suffix}`;
+	const coreLibPath = join(binDir, coreLibFileName);
+
+	if (!existsSync(coreLibPath)) {
+		throw new Error(`SparkBunCore not found at: ${coreLibPath}`);
+	}
+
+	const lib = dlopen(coreLibPath, {
+		sparkbun_core_run_main_thread: {
+			args: ["cstring", "cstring", "cstring", "i32"],
+			returns: "i32",
+		},
+	});
+
+	let channel = "";
+	let identifier = "";
+	let name = "";
+	try {
+		const versionJsonPath = join(bundleRoot, "Resources", "version.json");
+		if (existsSync(versionJsonPath)) {
+			const versionInfo = require(versionJsonPath);
+			identifier = versionInfo.identifier || "";
+			name = versionInfo.name || "";
+			channel = versionInfo.channel || "";
+		}
+	} catch {}
+
+	lib.symbols.sparkbun_core_run_main_thread(
+		Buffer.from((identifier || metadata.name) + "\0", "utf-8"),
+		Buffer.from((name || metadata.name) + "\0", "utf-8"),
+		Buffer.from(channel + "\0", "utf-8"),
+		0,
+	);
+
+	// Cleanup temp on exit
+	try {
+		rmSync(tempDir, { recursive: true, force: true });
+	} catch {}
+} catch (e: any) {
+	console.error(`Installer failed: ${e.message}`);
+	try {
+		rmSync(tempDir, { recursive: true, force: true });
+	} catch {}
+	if (process.platform === "win32") {
+		console.log("Press Enter to exit...");
+		for await (const _ of console) { break; }
+	}
+	process.exit(1);
+}