sparkbun 0.2.0 → 0.2.2

package/package.json

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

package/src/cli/index.ts

@@ -3198,6 +3198,23 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		// stapler validate -v <app path>
 	}
 
+	/**
+	 * Build a graphical installer as a single-file executable.
+	 *
+	 * The output is a SparkBun app compiled into one binary. It uses a two-phase
+	 * execution model: on first launch it extracts a small runtime bundle (~1MB
+	 * of DLLs, views, app code) to temp, copies itself there, and re-launches
+	 * with admin elevation. On second launch (from temp, with DLLs present) it
+	 * loads SparkBunCore and runs the webview-based installer UI.
+	 *
+	 * Payload archives are compressed with LZMA via NSIS and embedded directly
+	 * in the binary. They stay embedded until the user triggers installation,
+	 * at which point the app code writes them to disk and runs them as silent
+	 * self-extractors.
+	 *
+	 * This is a separate pipeline from `runBuild` — it does not produce update
+	 * artifacts, delta patches, DMGs, or .deb packages.
+	 */
 	async function runInstallerBuild(
 		config: Awaited<ReturnType<typeof getConfig>>,
 		buildEnvironment: "dev" | "stable",
@@ -3529,6 +3546,7 @@ ${archiveExports.join("\n")}
 		const installerCompileOptions: any = {
 			target: `bun-${targetOSName}-${targetARCH}`,
 			outfile: outputPath,
+			minify: true,
 		};
 
 		if (isWindows && OS === "win") {
@@ -3547,7 +3565,9 @@ ${archiveExports.join("\n")}
 				}
 			}
 			installerCompileOptions.windows = {
-				hideConsole: true,
+				// Don't set hideConsole — it conflicts with the ShellExecuteW("runas")
+				// elevation flow in the wrapper template. The PE subsystem patch
+				// (CONSOLE -> WINDOWS) applied after compilation hides the console.
 				...(icoPath && { icon: icoPath }),
 				title: `${installerName} Setup`,
 				version: installerVersion,

package/src/core/main.zig

@@ -900,8 +900,6 @@ export fn configureWebviewRuntime(
 ) bool {
     clearLastError();
 
-    webview_runtime_state.rpc_port = rpc_port;
-
     if (!replaceOptionalOwnedZ(&webview_runtime_state.preload_script, preload_script)) {
         return false;
     }
@@ -913,6 +911,16 @@ export fn configureWebviewRuntime(
         return false;
     }
 
+    // On Windows, skip the WebSocket transport server — RPC goes through
+    // the native WebView2 host bridge (postMessage) instead.
+    if (comptime builtin.os.tag == .windows) {
+        webview_runtime_state.rpc_port = 0;
+        webview_runtime_state.configured = true;
+        return true;
+    }
+
+    webview_runtime_state.rpc_port = rpc_port;
+
     if (!startHostTransportServer(rpc_port)) {
         return false;
     }

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

@@ -1,119 +1,57 @@
+/**
+ * SparkBun Installer Wrapper Template
+ *
+ * This file is the entrypoint for installers built with `bun sparkbun installer`.
+ * It gets compiled into a single executable that contains:
+ *   - A small runtime bundle (DLLs, views, app code — ~1MB compressed)
+ *   - The installer's payload archives (LZMA compressed via NSIS)
+ *
+ * The binary uses a two-phase execution model with a single Bun runtime:
+ *
+ *   Phase 1 (first launch — user double-clicks the exe):
+ *     No native DLLs next to the exe, so we can't load SparkBunCore yet.
+ *     Extract the runtime bundle to a temp directory, copy ourselves there
+ *     (so the same binary now has DLLs next to it), and re-launch the copy
+ *     with admin elevation via ShellExecuteW("runas"). The UAC prompt shows
+ *     the exe's PE metadata (app name, publisher) since Windows reads it
+ *     from the binary being elevated.
+ *
+ *   Phase 2 (second launch — from temp, elevated):
+ *     DLLs are next to us. Load SparkBunCore via FFI, start the app code
+ *     as a Worker thread, and run the native event loop. The app code opens
+ *     a webview window (the installer wizard UI) and can access the embedded
+ *     payload archives via globalThis.__installerArchives when the user
+ *     triggers installation.
+ *
+ * The payload archives stay embedded in the binary at all times — they are
+ * never extracted to temp. Only when the user clicks "Install" does the app
+ * code write them to disk and run them (NSIS silent self-extractors).
+ */
+
 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 { join, dirname, basename } from "path";
+import { existsSync, mkdirSync, readdirSync, copyFileSync } 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 metadata = await Bun.file(metadataJson).json();
+const binDir = dirname(process.execPath);
+const coreLibName = process.platform === "win32"
+	? "SparkBunCore.dll"
+	: `libSparkBunCore.${suffix}`;
+const hasRuntime = existsSync(join(binDir, coreLibName));
 
-	const archiveBytes = await Bun.file(runtimeArchive).bytes();
-	const archive = new Bun.Archive(archiveBytes);
-	mkdirSync(tempDir, { recursive: true });
-	await archive.extract(tempDir);
+if (hasRuntime) {
+	// ── Phase 2: DLLs are next to us — run the SparkBun app ──
 
-	// 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}`);
-	}
+	// Expose embedded archives to the app code via globalThis.
+	// The app's install logic reads these paths to extract payloads.
+	(globalThis as any).__installerArchives = embeddedArchives;
 
+	const coreLibPath = join(binDir, coreLibName);
 	const lib = dlopen(coreLibPath, {
 		sparkbun_core_run_main_thread: {
 			args: ["cstring", "cstring", "cstring", "i32"],
@@ -121,38 +59,87 @@ try {
 		},
 	});
 
+	const resourcesDir = join(binDir, "..", "Resources");
+	const appEntrypointPath = join(resourcesDir, "app", "bun", "index.js");
+
+	// Read app identity from build.json for SparkBunCore initialization
+	let identifier = metadata.name || "";
+	let name = metadata.name || "";
 	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 || "";
+		const buildJsonPath = join(resourcesDir, "app", "build.json");
+		if (existsSync(buildJsonPath)) {
+			const buildConfig = JSON.parse(require("fs").readFileSync(buildJsonPath, "utf-8"));
+			identifier = buildConfig.identifier || identifier;
+			name = buildConfig.name || name;
+			channel = buildConfig.channel || "";
 		}
 	} catch {}
 
+	// Suppress default signal handling so the native event loop controls shutdown
+	process.on("SIGINT", () => {});
+	process.on("SIGTERM", () => {});
+
+	// Start the app code in a Worker thread (same pattern as SparkBun's launcher).
+	// The Worker runs the developer's Bun entrypoint which creates BrowserWindows,
+	// sets up RPC handlers, etc.
+	new Worker(appEntrypointPath);
+
+	// Run the native event loop on the main thread (blocks until app exits)
 	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"),
+		ptr(new Uint8Array(Buffer.from(identifier + "\0", "utf8"))),
+		ptr(new Uint8Array(Buffer.from(name + "\0", "utf8"))),
+		ptr(new Uint8Array(Buffer.from(channel + "\0", "utf8"))),
 		0,
 	);
+} else {
+	// ── Phase 1: No DLLs — extract runtime, copy self, launch elevated ──
 
-	// 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; }
+	const tempDir = join(
+		process.env.TEMP || process.env.LOCALAPPDATA || ".",
+		`.sparkbun-installer-${metadata.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+	);
+
+	mkdirSync(tempDir, { recursive: true });
+	const archiveBytes = await Bun.file(runtimeArchive).bytes();
+	const archive = new Bun.Archive(archiveBytes);
+	await archive.extract(tempDir);
+
+	// The runtime bundle extracts as AppName/bin/ with DLLs inside
+	let extractedBinDir = tempDir;
+	for (const entry of readdirSync(tempDir)) {
+		const entryPath = join(tempDir, entry);
+		if (existsSync(join(entryPath, "bin"))) {
+			extractedBinDir = join(entryPath, "bin");
+			break;
+		}
+	}
+
+	// Copy ourselves next to the DLLs so the second launch detects hasRuntime
+	const destExe = join(extractedBinDir, basename(process.execPath));
+	copyFileSync(process.execPath, destExe);
+
+	// Launch the copy with elevation using the same pattern as installer-template.ts.
+	// ShellExecuteW("runas") triggers the UAC prompt showing the exe's PE metadata.
+	if (process.platform === "win32" && metadata.requireAdmin) {
+		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(destExe),
+			null,
+			encode(extractedBinDir),
+			1,
+		);
+		shell32.close();
+	} else {
+		Bun.spawn([destExe], { cwd: extractedBinDir });
 	}
-	process.exit(1);
+	await Bun.sleep(1000);
 }