sparkbun 0.1.0

package/src/extractor/build.zig

@@ -0,0 +1,22 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    // zig build -Doptimize=Debug to enable debug mode
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const exe = b.addExecutable(.{
+        .name = "extractor",
+        .root_source_file = b.path("main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // Link with libc for chmod and other system calls
+    exe.linkLibC();
+
+    // Use Console subsystem on all platforms so users can see extraction progress
+    // The console window will automatically close when extraction completes
+
+    b.installArtifact(exe);
+}

package/src/installer/installer-template.ts

@@ -0,0 +1,216 @@
+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, chmodSync, readdirSync } from "fs";
+
+interface Metadata {
+	identifier: string;
+	name: string;
+	channel: string;
+	hash: string;
+	requireAdmin?: boolean;
+}
+
+const metadata: Metadata = await Bun.file(metadataJson).json();
+const appName = metadata.name;
+const exeName = metadata.name.replace(/ /g, "");
+const installDir = getInstallDir(metadata);
+
+try {
+	console.log();
+	console.log(`Installing ${appName}...`);
+
+	const archiveBytes = await Bun.file(archiveData).bytes();
+	const archive = new Bun.Archive(archiveBytes);
+	mkdirSync(installDir, { recursive: true });
+	await archive.extract(installDir);
+	console.log(`Extracted to ${installDir}`);
+
+	let appDir = installDir;
+	// Look for the app bundle folder inside the extraction dir
+	const entries = readdirSync(installDir);
+	for (const entry of entries) {
+		const entryPath = join(installDir, entry);
+		if (existsSync(join(entryPath, "bin"))) {
+			appDir = entryPath;
+			break;
+		}
+	}
+
+	if (process.platform === "win32") {
+		await createWindowsShortcuts(appDir, metadata);
+	} else if (process.platform === "linux") {
+		fixPermissions(appDir);
+		await createLinuxDesktopEntry(appDir, metadata);
+	}
+
+	// Launch the app
+	const launcherName = process.platform === "win32" ? `${exeName}.exe` : exeName;
+	const launcherPath = join(appDir, "bin", launcherName);
+
+	if (existsSync(launcherPath)) {
+		console.log(`Launching ${appName}...`);
+		if (process.platform === "win32" && metadata.requireAdmin) {
+			const { dlopen, ptr } = await import("bun:ffi");
+			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(launcherPath),
+				null,
+				encode(join(appDir, "bin")),
+				1,
+			);
+			shell32.close();
+		} else {
+			Bun.spawn([launcherPath], { cwd: join(appDir, "bin") });
+		}
+		await Bun.sleep(1000);
+	}
+} catch (e: any) {
+	console.error(`Installation failed: ${e.message}`);
+	if (process.platform === "win32") {
+		console.log("Press Enter to exit...");
+		for await (const _ of console) { break; }
+	}
+	process.exit(1);
+}
+
+function getInstallDir(meta: Metadata): string {
+	if (process.platform === "win32") {
+		const localAppData = process.env.LOCALAPPDATA || join(process.env.USERPROFILE || "", "AppData", "Local");
+		return join(localAppData, meta.identifier, meta.channel, "app");
+	} else {
+		const dataHome = process.env.XDG_DATA_HOME || join(process.env.HOME || "", ".local", "share");
+		return join(dataHome, meta.identifier, meta.channel, "app");
+	}
+}
+
+async function createWindowsShortcuts(appDir: string, meta: Metadata) {
+	const binDir = join(appDir, "bin");
+	const exePath = join(binDir, `${meta.name.replace(/ /g, "")}.exe`);
+
+	if (!existsSync(exePath)) return;
+
+	// Start Menu shortcut
+	const startMenu = join(process.env.APPDATA || "", "Microsoft", "Windows", "Start Menu", "Programs");
+	try {
+		Bun.spawnSync(["powershell", "-NoProfile", "-Command",
+			`$ws = New-Object -ComObject WScript.Shell; $s = $ws.CreateShortcut('${join(startMenu, meta.name + ".lnk")}'); $s.TargetPath = '${exePath}'; $s.WorkingDirectory = '${binDir}'; $s.Save()`
+		]);
+	} catch {}
+
+	// Desktop shortcut
+	try {
+		const desktop = join(process.env.USERPROFILE || "", "Desktop");
+		Bun.spawnSync(["powershell", "-NoProfile", "-Command",
+			`$ws = New-Object -ComObject WScript.Shell; $s = $ws.CreateShortcut('${join(desktop, meta.name + ".lnk")}'); $s.TargetPath = '${exePath}'; $s.WorkingDirectory = '${binDir}'; $s.Save()`
+		]);
+	} catch {}
+
+	console.log("Created Start Menu and Desktop shortcuts");
+}
+
+function fixPermissions(appDir: string) {
+	const exeBaseName = appDir.split("/").pop()?.replace(/ /g, "") || "app";
+	const executables = [`bin/${exeBaseName}`, "bin/bspatch", "bin/bsdiff"];
+	for (const exe of executables) {
+		const path = join(appDir, exe);
+		if (existsSync(path)) {
+			try { chmodSync(path, 0o755); } catch {}
+		}
+	}
+}
+
+async function createLinuxDesktopEntry(appDir: string, meta: Metadata) {
+	const launcherPath = join(appDir, "bin", meta.name.replace(/ /g, ""));
+	if (!existsSync(launcherPath)) return;
+
+	// Find icon
+	let iconPath = "";
+	const resourcesDir = join(appDir, "Resources");
+	if (existsSync(resourcesDir)) {
+		const pngs = readdirSync(resourcesDir).filter(f => f.endsWith(".png"));
+		if (pngs.length > 0) iconPath = join(resourcesDir, pngs[0]);
+	}
+
+	// If requireAdmin, install polkit policy and use pkexec in Exec line
+	if (meta.requireAdmin) {
+		await installPolkitPolicy(launcherPath, meta);
+	}
+
+	const execLine = meta.requireAdmin
+		? `pkexec "${launcherPath}"`
+		: `"${launcherPath}"`;
+
+	const desktopContent = `[Desktop Entry]
+Version=1.0
+Type=Application
+Name=${meta.name}
+Exec=${execLine}
+Icon=${iconPath}
+Terminal=false
+StartupWMClass=${meta.name}
+Categories=Utility;Application;
+`;
+
+	// Write to XDG applications directory
+	const dataHome = process.env.XDG_DATA_HOME || join(process.env.HOME || "", ".local", "share");
+	const applicationsDir = join(dataHome, "applications");
+	mkdirSync(applicationsDir, { recursive: true });
+
+	const desktopFilePath = join(applicationsDir, `${meta.name}.desktop`);
+	await Bun.write(desktopFilePath, desktopContent);
+	chmodSync(desktopFilePath, 0o644);
+
+	// Desktop shortcut
+	const desktopDir = join(process.env.HOME || "", "Desktop");
+	if (existsSync(desktopDir)) {
+		const desktopShortcut = join(desktopDir, `${meta.name}.desktop`);
+		await Bun.write(desktopShortcut, desktopContent);
+		chmodSync(desktopShortcut, 0o755);
+		try {
+			Bun.spawnSync(["gio", "set", desktopShortcut, "metadata::trusted", "true"]);
+		} catch {}
+	}
+
+	console.log("Created desktop entries");
+}
+
+async function installPolkitPolicy(launcherPath: string, meta: Metadata) {
+	const policyId = meta.identifier.replace(/-/g, ".");
+	const policyContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
+<policyconfig>
+  <action id="${policyId}.run">
+    <description>Run ${meta.name}</description>
+    <message>Authentication is required to run ${meta.name}</message>
+    <defaults>
+      <allow_any>auth_admin</allow_any>
+      <allow_inactive>auth_admin</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">${launcherPath}</annotate>
+    <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate>
+  </action>
+</policyconfig>
+`;
+
+	const policyDir = "/usr/share/polkit-1/actions";
+	const policyPath = join(policyDir, `${policyId}.policy`);
+
+	try {
+		await Bun.write(policyPath, policyContent);
+		console.log(`Installed polkit policy: ${policyPath}`);
+	} catch {
+		console.log("Note: Could not install polkit policy (may need root). The app will still prompt for authentication via pkexec.");
+	}
+}

package/src/launcher/main.ts

@@ -0,0 +1,221 @@
+import { join, dirname, resolve } from "path";
+import { dlopen, suffix, ptr } from "bun:ffi";
+import { existsSync } from "fs";
+
+// Set CWD to bin/ directory where the binary lives.
+// Without this, pkexec sets CWD to $HOME and all ../Resources/ paths break.
+const pathToMacOS = dirname(process.argv0);
+process.chdir(pathToMacOS);
+const coreLibFileName =
+	process.platform === "win32"
+		? "ElectrobunCore.dll"
+		: `libElectrobunCore.${suffix}`;
+const coreLibPath = join(pathToMacOS, coreLibFileName);
+const absoluteCoreLibPath = resolve(coreLibPath);
+
+function 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;
+}
+
+function elevateAndExit(): void {
+	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.argv0),
+			null,
+			null,
+			1, // SW_SHOWNORMAL
+		);
+		shell32.close();
+	} else if (process.platform === "linux") {
+		Bun.spawnSync(["pkexec", process.argv0, ...process.argv.slice(1)], {
+			stdout: "inherit",
+			stderr: "inherit",
+		});
+	}
+	process.exit(0);
+}
+
+// Wrap main logic in a function to avoid top-level return
+function main() {
+	// Read version.json early to get identifier, name, and channel for CEF initialization
+	let channel = "";
+	let identifier = "";
+	let name = "";
+	try {
+		const pathToLauncherBin = process.argv0;
+		const pathToBinDir = dirname(pathToLauncherBin);
+		const versionJsonPath = join(
+			pathToBinDir,
+			"..",
+			"Resources",
+			"version.json",
+		);
+
+		if (existsSync(versionJsonPath)) {
+			const versionInfo = require(versionJsonPath);
+			if (versionInfo.identifier) {
+				identifier = versionInfo.identifier;
+			}
+			if (versionInfo.name) {
+				name = versionInfo.name;
+			}
+			if (versionInfo.channel) {
+				channel = versionInfo.channel;
+			}
+			console.log(
+				`[LAUNCHER] Loaded identifier: ${identifier}, name: ${name}, channel: ${channel}`,
+			);
+		}
+	} catch (error) {
+		console.error(`[LAUNCHER] Warning: Could not read version.json:`, error);
+		// Continue anyway - this is not critical for dev builds
+	}
+
+	// Check if admin elevation is required
+	if (process.platform !== "darwin") {
+		try {
+			const binDir = dirname(process.argv0);
+			const buildJsonPath = join(binDir, "..", "Resources", "build.json");
+			if (existsSync(buildJsonPath)) {
+				const buildConfig = JSON.parse(
+					require("fs").readFileSync(buildJsonPath, "utf-8"),
+				);
+				if (buildConfig.requireAdmin && !isAdmin()) {
+					console.log("[LAUNCHER] Admin required, elevating...");
+					elevateAndExit();
+					return;
+				} else if (buildConfig.requireAdmin) {
+					console.log("[LAUNCHER] Already running as admin");
+				}
+			}
+		} catch (error) {
+			console.error(`[LAUNCHER] Warning: Could not check admin requirement:`, error);
+		}
+	}
+
+	// Check for CEF libraries and warn if LD_PRELOAD not set (Linux only)
+	if (process.platform === "linux") {
+		const cefLibs = [
+			join(pathToMacOS, "libcef.so"),
+			join(pathToMacOS, "libvk_swiftshader.so"),
+		];
+		const existingCefLibs = cefLibs.filter((lib) => existsSync(lib));
+
+		if (existingCefLibs.length > 0 && !process.env["LD_PRELOAD"]) {
+			console.error(
+				`[LAUNCHER] ERROR: CEF libraries found but LD_PRELOAD not set!`,
+			);
+			console.error(
+				`[LAUNCHER] Please run through the wrapper script: ./run.sh`,
+			);
+			console.error(
+				`[LAUNCHER] Or set: LD_PRELOAD="${existingCefLibs.join(":")}" before starting.`,
+			);
+
+			// Try to re-exec ourselves with LD_PRELOAD set
+			const { spawn } = require("child_process");
+			const env = { ...process.env, LD_PRELOAD: existingCefLibs.join(":") };
+			const child = spawn(process.argv[0], process.argv.slice(1), {
+				env,
+				stdio: "inherit",
+			});
+			child.on("exit", (code: number | null) => process.exit(code ?? 1));
+			return; // Don't continue in this process
+		}
+	}
+
+	let lib;
+	try {
+
+		lib = dlopen(coreLibPath, {
+			electrobun_core_run_main_thread: {
+				args: ["cstring", "cstring", "cstring", "i32"],
+				returns: "i32",
+			},
+			electrobun_core_last_error: {
+				args: [],
+				returns: "cstring",
+			},
+		});
+	} catch (error) {
+		console.error(
+			`[LAUNCHER] Failed to load ElectrobunCore: ${(error as Error).message}`,
+		);
+
+		// Try with absolute path as fallback
+		try {
+			lib = dlopen(absoluteCoreLibPath, {
+				electrobun_core_run_main_thread: {
+					args: ["cstring", "cstring", "cstring", "i32"],
+					returns: "i32",
+				},
+				electrobun_core_last_error: {
+					args: [],
+					returns: "cstring",
+				},
+			});
+		} catch (absError) {
+			console.error(
+				`[LAUNCHER] Core library loading failed. Try running: ldd ${coreLibPath}`,
+			);
+			throw error;
+		}
+	}
+
+	// from different locations
+	const pathToLauncherBin = process.argv0;
+	const pathToBinDir = dirname(pathToLauncherBin);
+
+	const resourcesDir = join(pathToBinDir, "..", "Resources");
+	const appFolderPath = join(resourcesDir, "app");
+	const appEntrypointPath = join(appFolderPath, "bun", "index.js");
+
+	// Register signal handlers on the main thread to prevent default termination.
+	// The worker thread's SIGINT handler will call quit() for graceful shutdown.
+	// Without these, SIGINT kills the process before the worker can run beforeQuit.
+	process.on("SIGINT", () => {});
+	process.on("SIGTERM", () => {});
+
+	new Worker(appEntrypointPath, {
+		// consider adding a preload with error handling
+		// preload: [''];
+	});
+
+	const runStatus = lib.symbols.electrobun_core_run_main_thread(
+		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,
+	);
+
+	if (runStatus !== 0) {
+		const coreError = lib.symbols.electrobun_core_last_error();
+		console.error(
+			`[LAUNCHER] ElectrobunCore failed: ${coreError ? coreError.toString() : "Unknown error"}`,
+		);
+		process.exit(runStatus);
+	}
+}
+
+// Call the main function
+main();

package/src/native/linux/cef_loader.cpp

@@ -0,0 +1,110 @@
+#include "cef_loader.h"
+#include <iostream>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <limits.h>
+#include <cstdlib>
+#include <cstring>
+
+// Static member definitions
+void* CefLoader::cef_lib_handle = nullptr;
+std::atomic<bool> CefLoader::initialized(false);
+std::atomic<bool> CefLoader::load_attempted(false);
+
+std::string CefLoader::GetCefLibraryPath() {
+    // Get the executable directory
+    char exe_path[PATH_MAX];
+    ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1);
+    if (len == -1) return "";
+    
+    exe_path[len] = '\0';
+    std::string execPath(exe_path);
+    size_t pos = execPath.find_last_of('/');
+    if (pos != std::string::npos) {
+        execPath = execPath.substr(0, pos);
+    }
+    
+    // Check primary location: execDir/cef/libcef.so
+    std::string cefLibPath = execPath + "/cef/libcef.so";
+    struct stat buffer;
+    if (stat(cefLibPath.c_str(), &buffer) == 0) {
+        return cefLibPath;
+    }
+    
+    // Check fallback location: execDir/libcef.so
+    cefLibPath = execPath + "/libcef.so";
+    if (stat(cefLibPath.c_str(), &buffer) == 0) {
+        return cefLibPath;
+    }
+    
+    return "";
+}
+
+bool CefLoader::Initialize() {
+    // Only attempt to load once
+    bool expected = false;
+    if (!load_attempted.compare_exchange_strong(expected, true)) {
+        return initialized.load();
+    }
+    
+    // Get CEF library path
+    std::string cefPath = GetCefLibraryPath();
+    if (cefPath.empty()) {
+        std::cout << "CEF library not found - CEF features will be disabled" << std::endl;
+        return false;
+    }
+    
+    std::cout << "Attempting to load CEF from: " << cefPath << std::endl;
+    
+    // Extract directory for LD_LIBRARY_PATH
+    std::string cefDir;
+    size_t pos = cefPath.find_last_of('/');
+    if (pos != std::string::npos) {
+        cefDir = cefPath.substr(0, pos);
+    }
+    
+    // Set LD_LIBRARY_PATH to include the CEF directory for dependent libraries
+    const char* existing_ld_path = getenv("LD_LIBRARY_PATH");
+    std::string new_ld_path = cefDir;
+    if (existing_ld_path && strlen(existing_ld_path) > 0) {
+        new_ld_path += ":";
+        new_ld_path += existing_ld_path;
+    }
+    setenv("LD_LIBRARY_PATH", new_ld_path.c_str(), 1);
+    
+    // Also set LD_LIBRARY_PATH for the current process using dlopen hack
+    // This ensures dependent libraries can be found
+    void* handle = dlopen(nullptr, RTLD_LAZY | RTLD_GLOBAL);
+    if (handle) {
+        dlclose(handle);
+    }
+    
+    // Load CEF library with RTLD_GLOBAL to make all symbols available globally
+    // This allows CEF to be used normally without function pointers
+    cef_lib_handle = dlopen(cefPath.c_str(), RTLD_NOW | RTLD_GLOBAL);
+    if (!cef_lib_handle) {
+        const char* error = dlerror();
+        std::cerr << "Failed to load CEF library: " << (error ? error : "unknown error") << std::endl;
+        
+        // Try to provide more helpful error messages
+        if (error && strstr(error, "cannot open shared object file")) {
+            std::cerr << "Make sure all CEF dependencies are in the same directory as libcef.so" << std::endl;
+            std::cerr << "LD_LIBRARY_PATH was set to: " << new_ld_path << std::endl;
+        }
+        return false;
+    }
+    
+    // Verify critical symbols are available
+    dlerror(); // Clear any existing errors
+    void* init_sym = dlsym(cef_lib_handle, "cef_initialize");
+    if (!init_sym) {
+        std::cerr << "CEF library loaded but cef_initialize symbol not found: " << dlerror() << std::endl;
+        dlclose(cef_lib_handle);
+        cef_lib_handle = nullptr;
+        return false;
+    }
+    
+    initialized.store(true);
+    std::cout << "CEF library loaded successfully" << std::endl;
+    return true;
+}

package/src/native/linux/cef_loader.h

@@ -0,0 +1,28 @@
+#ifndef CEF_LOADER_H
+#define CEF_LOADER_H
+
+#include <dlfcn.h>
+#include <string>
+#include <atomic>
+
+// Dynamic CEF loading wrapper for weak linking on Linux
+// This uses dlopen with RTLD_GLOBAL to make all CEF symbols available
+// globally, which allows us to use CEF normally without function pointers
+class CefLoader {
+private:
+    static void* cef_lib_handle;
+    static std::atomic<bool> initialized;
+    static std::atomic<bool> load_attempted;
+
+public:
+    // Initialize the loader and attempt to load CEF
+    static bool Initialize();
+    
+    // Check if CEF is loaded and available
+    static bool IsLoaded() { return initialized.load(); }
+    
+    // Get the path to libcef.so
+    static std::string GetCefLibraryPath();
+};
+
+#endif // CEF_LOADER_H