sparkbun 0.1.8 → 0.1.9

package/package.json

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

package/src/cli/index.ts

@@ -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(
@@ -3187,6 +3198,394 @@ 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 });
+
+		// --- Create app 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 });
+
+		// --- Compile launcher ---
+
+		const launcherBinaryName = config.app.name.replace(/ /g, "");
+		const launcherDestination = join(appBundleMacOSPath, launcherBinaryName) + targetBinExt;
+		mkdirSync(dirname(launcherDestination), { recursive: true });
+
+		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;
+
+		const compileOptions: any = {
+			target: bunTarget,
+			outfile: launcherDestination,
+		};
+
+		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;
+					}
+				}
+			}
+			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");
+		}
+
+		if (targetOS === "win") {
+			patchPeSubsystem(launcherDestination);
+		}
+
+		// --- 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));
+
+		// --- 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);
+
+				const gzSize = statSync(archiveDestPath).size;
+				console.log(`  ${name}: ${(gzSize / 1024 / 1024).toFixed(2)} MB`);
+				archiveManifest[name] = archiveFileName;
+			}
+
+			// Write archives.json manifest
+			await Bun.write(
+				join(appBundleFolderResourcesPath, "archives.json"),
+				JSON.stringify(archiveManifest, null, 2),
+			);
+			console.log(`Archives manifest written (${archives.length} archives)`);
+		}
+
+		// --- 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
+		rmSync(appBundleFolderPath, { recursive: true });
+
+		// --- Compile outer 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 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"));
+
+		// Write metadata
+		const metadata: Record<string, unknown> = {
+			name: installerName,
+			version: installerVersion,
+			identifier: config.app.identifier,
+			channel: buildEnvironment,
+		};
+		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));
+
+		// Copy wrapper template
+		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";
+
+		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

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

@@ -0,0 +1,69 @@
+import archiveData from "./app-archive.tar.gz" with { type: "file" };
+import metadataJson from "./metadata.json" with { type: "file" };
+import { join } from "path";
+import { existsSync, mkdirSync, rmSync } from "fs";
+
+interface Metadata {
+	name: string;
+	version?: string;
+}
+
+const metadata: Metadata = await Bun.file(metadataJson).json();
+const tempDir = join(
+	process.env.TEMP || process.env.TMP || process.env.LOCALAPPDATA || ".",
+	`.sparkbun-installer-${Date.now()}`,
+);
+
+try {
+	console.log(`Starting ${metadata.name} installer...`);
+
+	const archiveBytes = await Bun.file(archiveData).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) {
+		const entryPath = join(tempDir, entry);
+		if (existsSync(join(entryPath, "bin"))) {
+			appDir = entryPath;
+			break;
+		}
+	}
+
+	const exeName = metadata.name.replace(/ /g, "");
+	const binExt = process.platform === "win32" ? ".exe" : "";
+	const launcherPath = join(appDir, "bin", `${exeName}${binExt}`);
+
+	if (!existsSync(launcherPath)) {
+		throw new Error(`Launcher not found: ${launcherPath}`);
+	}
+
+	const proc = Bun.spawn([launcherPath], {
+		cwd: join(appDir, "bin"),
+		stdio: ["inherit", "inherit", "inherit"],
+	});
+
+	const exitCode = await proc.exited;
+
+	// Clean up temp directory
+	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 {}
+	if (process.platform === "win32") {
+		console.log("Press Enter to exit...");
+		for await (const _ of console) { break; }
+	}
+	process.exit(1);
+}