sparkbun 0.1.9 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sparkbun",
-	"version": "0.1.9",
+	"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;
@@ -2078,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;
@@ -3282,76 +3282,74 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 		mkdirSync(buildFolder, { recursive: true });
 
-		// --- Create app bundle ---
+		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";
 
-		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 });
+		// --- Create archives first (they go into the compiled binary, not the runtime bundle) ---
 
-		// --- Compile launcher ---
+		const stagingDir = join(buildFolder, ".installer-staging");
+		if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
+		mkdirSync(stagingDir, { recursive: true });
 
-		const launcherBinaryName = config.app.name.replace(/ /g, "");
-		const launcherDestination = join(appBundleMacOSPath, launcherBinaryName) + targetBinExt;
-		mkdirSync(dirname(launcherDestination), { recursive: true });
+		const archiveManifest: Record<string, string> = {};
 
-		const cliDir = dirname(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"}-${targetARCH}` as const;
+		if (archives.length > 0) {
+			console.log("Creating archives (LZMA solid via NSIS)...");
 
-		const compileOptions: any = {
-			target: bunTarget,
-			outfile: launcherDestination,
-		};
+			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/`);
+			}
 
-		if (targetOS === "win" && OS === "win") {
-			let icoPath: string | undefined;
-			if (config.build.win?.icon) {
-				const iconSrc = config.build.win.icon.startsWith("/") || config.build.win.icon.match(/^[a-zA-Z]:/)
-					? config.build.win.icon
-					: join(projectRoot, config.build.win.icon);
-				if (existsSync(iconSrc)) {
-					icoPath = iconSrc;
-					if (iconSrc.toLowerCase().endsWith(".png")) {
-						const pngToIco = (await import("png-to-ico")).default;
-						const tempIcoPath = join(buildFolder, "temp-launcher-icon.ico");
-						const icoBuffer = await pngToIco(iconSrc);
-						writeFileSync(tempIcoPath, new Uint8Array(icoBuffer));
-						icoPath = tempIcoPath;
-					}
+			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}`);
 				}
-			}
-			compileOptions.windows = {
-				hideConsole: true,
-				...(icoPath && { icon: icoPath }),
-				title: config.app.name,
-				version: installerVersion,
-				description: config.app.name,
-				publisher: installerPublisher || " ",
-				copyright: (config.app as any).copyright || " ",
-			};
-		}
 
-		console.log("Compiling installer launcher...");
-		const launcherBuild = await Bun.build({
-			entrypoints: [launcherSourcePath],
-			compile: compileOptions,
-		});
-		if (!launcherBuild.success) {
-			console.error("Launcher compilation failed:", launcherBuild.logs);
-			throw new Error("Launcher compilation failed");
-		}
+				unlinkSync(nsiPath);
 
-		if (targetOS === "win") {
-			patchPeSubsystem(launcherDestination);
+				const archiveSize = statSync(archiveDestPath).size;
+				console.log(`  ${name}: ${(archiveSize / 1024 / 1024).toFixed(2)} MB`);
+				archiveManifest[name] = archiveFileName;
+			}
 		}
 
-		// --- Copy native wrappers ---
+		// --- 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 });
@@ -3372,8 +3370,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			cpSync(asarLibSource, join(appBundleMacOSPath, "libasar" + libExt), { dereference: true });
 		}
 
-		// --- Bundle bun code ---
-
+		// Bundle bun code
 		const bunConfig = config.build.bun;
 		const bunSource = join(projectRoot, bunConfig.entrypoint);
 		if (!existsSync(bunSource)) {
@@ -3394,8 +3391,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			throw new Error("Build failed: bun build failed");
 		}
 
-		// --- Bundle views ---
-
+		// Bundle views
 		for (const viewName in config.build.views) {
 			const viewConfig = config.build.views[viewName]!;
 			const viewSource = join(projectRoot, viewConfig.entrypoint);
@@ -3420,8 +3416,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			}
 		}
 
-		// --- Copy assets ---
-
+		// Copy assets
 		for (const relSource in config.build.copy) {
 			const source = join(projectRoot, relSource);
 			if (!existsSync(source)) {
@@ -3438,8 +3433,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			cpSync(source, destination, { recursive: true, dereference: true });
 		}
 
-		// --- Write build.json ---
-
+		// Write build.json
 		const buildJson = {
 			name: config.app.name,
 			identifier: config.app.identifier,
@@ -3449,69 +3443,42 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		};
 		await Bun.write(join(appBundleAppCodePath, "build.json"), JSON.stringify(buildJson, null, 2));
 
-		// --- Create and embed archives ---
-
-		if (archives.length > 0) {
-			console.log("Creating archives...");
-			const archiveManifest: Record<string, string> = {};
-
-			for (const { name, path: archiveSrcPath } of archives) {
-				const archiveFileName = `archive-${name}.tar.gz`;
-				const archiveDestPath = join(appBundleFolderResourcesPath, archiveFileName);
-
-				console.log(`  Archiving ${name}: ${archiveSrcPath}`);
-				const tarPath = join(buildFolder, `archive-${name}.tar`);
-				createTar(tarPath, dirname(archiveSrcPath), [basename(archiveSrcPath)]);
-
-				const tarBytes = readFileSync(tarPath);
-				const gzipped = Bun.gzipSync(tarBytes);
-				writeFileSync(archiveDestPath, gzipped);
-
-				// Clean up intermediate tar
-				unlinkSync(tarPath);
+		// 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),
+		);
 
-				const gzSize = statSync(archiveDestPath).size;
-				console.log(`  ${name}: ${(gzSize / 1024 / 1024).toFixed(2)} MB`);
-				archiveManifest[name] = archiveFileName;
+		// --- 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();
+				}
 			}
-
-			// Write archives.json manifest
-			await Bun.write(
-				join(appBundleFolderResourcesPath, "archives.json"),
-				JSON.stringify(archiveManifest, null, 2),
-			);
-			console.log(`Archives manifest written (${archives.length} archives)`);
 		}
+		await walkBundle(appBundleFolderPath, bundleBase);
 
-		// --- Tar + gzip the app bundle ---
-
-		console.log("Packaging app bundle...");
-		const tarPath = join(buildFolder, `${appFileName}.tar`);
-		createTar(tarPath, buildFolder, [basename(appBundleFolderPath)]);
-
-		const compressedTarPath = `${tarPath}.gz`;
-		const tarBytes = readFileSync(tarPath);
-		const gzipped = Bun.gzipSync(tarBytes);
-		writeFileSync(compressedTarPath, gzipped);
-		unlinkSync(tarPath);
-
-		// Clean up the uncompressed app bundle
+		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 });
 
-		// --- Compile outer installer exe ---
+		const runtimeSize = statSync(runtimeCompressedPath).size;
+		console.log(`  Runtime bundle: ${(runtimeSize / 1024 / 1024).toFixed(2)} MB`);
 
-		const defaultOutName = `${installerName.replace(/ /g, "-")}-Setup${targetBinExt}`;
-		const outputPath = outPath
-			? path.resolve(projectRoot, outPath)
-			: join(buildFolder, defaultOutName);
+		// --- Generate entrypoint and compile single installer exe ---
 
-		console.log("Compiling installer executable...");
-		const stagingDir = join(buildFolder, ".installer-wrapper-staging");
-		if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
-		mkdirSync(stagingDir, { recursive: true });
-
-		// Copy app bundle archive
-		copyFileSync(compressedTarPath, join(stagingDir, "app-archive.tar.gz"));
+		// Copy runtime bundle into staging
+		copyFileSync(runtimeCompressedPath, join(stagingDir, "runtime-bundle.tar.gz"));
 
 		// Write metadata
 		const metadata: Record<string, unknown> = {
@@ -3519,6 +3486,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			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"));
@@ -3526,12 +3494,37 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 		writeFileSync(join(stagingDir, "metadata.json"), JSON.stringify(metadata, null, 2));
 
-		// Copy wrapper template
+		// 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"));
 
-		const targetOSName = targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux";
-		const isWindows = targetOS === "win";
+		// 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}`,
@@ -4226,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

@@ -1,63 +1,152 @@
-import archiveData from "./app-archive.tar.gz" with { type: "file" };
+import runtimeArchive from "./runtime-bundle.tar.gz" with { type: "file" };
 import metadataJson from "./metadata.json" with { type: "file" };
-import { join } from "path";
-import { existsSync, mkdirSync, rmSync } from "fs";
+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-${Date.now()}`,
+	`.sparkbun-installer-${metadata.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
 );
 
 try {
-	console.log(`Starting ${metadata.name} installer...`);
+	if (existsSync(tempDir)) {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
 
-	const archiveBytes = await Bun.file(archiveData).bytes();
+	const archiveBytes = await Bun.file(runtimeArchive).bytes();
 	const archive = new Bun.Archive(archiveBytes);
 	mkdirSync(tempDir, { recursive: true });
 	await archive.extract(tempDir);
 
-	// Find the launcher exe inside the extracted bundle
-	const { readdirSync } = await import("fs");
-	let appDir = tempDir;
-	const entries = readdirSync(tempDir);
-	for (const entry of entries) {
+	// 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"))) {
-			appDir = entryPath;
+			binDir = join(entryPath, "bin");
+			bundleRoot = entryPath;
 			break;
 		}
 	}
 
-	const exeName = metadata.name.replace(/ /g, "");
-	const binExt = process.platform === "win32" ? ".exe" : "";
-	const launcherPath = join(appDir, "bin", `${exeName}${binExt}`);
+	// 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 (!existsSync(launcherPath)) {
-		throw new Error(`Launcher not found: ${launcherPath}`);
+		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);
+		}
 	}
 
-	const proc = Bun.spawn([launcherPath], {
-		cwd: join(appDir, "bin"),
-		stdio: ["inherit", "inherit", "inherit"],
+	// --- 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",
+		},
 	});
 
-	const exitCode = await proc.exited;
+	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,
+	);
 
-	// Clean up temp directory
+	// Cleanup temp on exit
 	try {
 		rmSync(tempDir, { recursive: true, force: true });
 	} catch {}
-
-	process.exit(exitCode);
 } catch (e: any) {
 	console.error(`Installer failed: ${e.message}`);
-	// Clean up on failure
 	try {
 		rmSync(tempDir, { recursive: true, force: true });
 	} catch {}