sparkbun 0.1.0

package/src/npmbin/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+import { platform } from "os";
+import { join, dirname } from "path";
+import { existsSync } from "fs";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+
+// Since this is sometimes run from a developer's package.json and sometimes from
+// electrobun's playground package.json script by the root electrobun repo's package.json script
+// we need to get the path to this file
+
+// Get the nearest node_modules folder
+// process.argv[1]:
+/// macos: /Users/yoav/code/electrobun/playground/node_modules/.bin/electrobun
+/// win: C:\Users\Yoav\code\electrobun\playground\node_modules\electrobun\dist\npmbin.js
+const nodeModules = process.argv[1].split("node_modules")[0] + "node_modules";
+const electrobunDir = join(nodeModules, "electrobun");
+
+const DEV_CLI_PATH = join(
+	electrobunDir,
+	"dist",
+	platform() === "win32" ? "electrobun.exe" : "electrobun",
+);
+
+async function main() {
+	// For electrobun development, use local binary
+	if (existsSync(DEV_CLI_PATH)) {
+		spawnSync(DEV_CLI_PATH, process.argv.slice(2), { stdio: "inherit" });
+		return;
+	}
+}
+
+main().catch(console.error);

package/src/shared/bun-version.ts

@@ -0,0 +1,3 @@
+// Default Bun version shipped with this SparkBun release.
+// All platforms use the same version. Update this when bumping Bun.
+export const BUN_VERSION = "1.3.13";

package/src/shared/cef-version.ts

@@ -0,0 +1,5 @@
+// Default CEF version shipped with this SparkBun release.
+// All platforms use the same version. Update this single pair when bumping CEF.
+export const CEF_VERSION = `147.0.10+gd58e84d`;
+export const CHROMIUM_VERSION = `147.0.7727.118`;
+export const DEFAULT_CEF_VERSION_STRING = `${CEF_VERSION}+chromium-${CHROMIUM_VERSION}`;

package/src/shared/naming.test.ts

@@ -0,0 +1,327 @@
+import { describe, expect, it } from "bun:test";
+import {
+	sanitizeAppName,
+	getAppFileName,
+	getBundleFileName,
+	getPlatformPrefix,
+	getTarballFileName,
+	getWindowsSetupFileName,
+	getLinuxAppImageBaseName,
+	getLinuxAppImageFileName,
+	sanitizeVolumeNameForHdiutil,
+	getDmgVolumeName,
+	getUpdateInfoUrl,
+	getPatchFileUrl,
+	getTarballUrl,
+} from "./naming";
+
+describe("sanitizeAppName", () => {
+	it("removes spaces from app name", () => {
+		expect(sanitizeAppName("My App")).toBe("MyApp");
+		expect(sanitizeAppName("My  Multi  Spaced  App")).toBe("MyMultiSpacedApp");
+	});
+
+	it("preserves names without spaces", () => {
+		expect(sanitizeAppName("MyApp")).toBe("MyApp");
+	});
+
+	it("handles empty string", () => {
+		expect(sanitizeAppName("")).toBe("");
+	});
+});
+
+describe("getAppFileName", () => {
+	it("returns sanitized name without suffix for stable builds", () => {
+		expect(getAppFileName("My App", "stable")).toBe("MyApp");
+	});
+
+	it("appends channel suffix for canary builds", () => {
+		expect(getAppFileName("My App", "canary")).toBe("MyApp-canary");
+	});
+
+	it("appends channel suffix for dev builds", () => {
+		expect(getAppFileName("My App", "dev")).toBe("MyApp-dev");
+	});
+
+	it("handles custom channels", () => {
+		expect(getAppFileName("My App", "beta")).toBe("MyApp-beta");
+		expect(getAppFileName("My App", "nightly")).toBe("MyApp-nightly");
+	});
+});
+
+describe("getBundleFileName", () => {
+	describe("macOS", () => {
+		it("adds .app extension for stable builds", () => {
+			expect(getBundleFileName("My App", "stable", "macos")).toBe("MyApp.app");
+		});
+
+		it("adds .app extension for canary builds", () => {
+			expect(getBundleFileName("My App", "canary", "macos")).toBe(
+				"MyApp-canary.app",
+			);
+		});
+	});
+
+	describe("Windows", () => {
+		it("returns plain name for stable builds", () => {
+			expect(getBundleFileName("My App", "stable", "win")).toBe("MyApp");
+		});
+
+		it("returns plain name with suffix for canary builds", () => {
+			expect(getBundleFileName("My App", "canary", "win")).toBe("MyApp-canary");
+		});
+	});
+
+	describe("Linux", () => {
+		it("returns plain name for stable builds", () => {
+			expect(getBundleFileName("My App", "stable", "linux")).toBe("MyApp");
+		});
+
+		it("returns plain name with suffix for canary builds", () => {
+			expect(getBundleFileName("My App", "canary", "linux")).toBe(
+				"MyApp-canary",
+			);
+		});
+	});
+});
+
+describe("getPlatformPrefix", () => {
+	it("constructs correct prefix format for all platform combinations", () => {
+		expect(getPlatformPrefix("stable", "macos", "arm64")).toBe(
+			"stable-macos-arm64",
+		);
+		expect(getPlatformPrefix("stable", "macos", "x64")).toBe(
+			"stable-macos-x64",
+		);
+		expect(getPlatformPrefix("canary", "win", "x64")).toBe("canary-win-x64");
+		expect(getPlatformPrefix("dev", "linux", "arm64")).toBe("dev-linux-arm64");
+		expect(getPlatformPrefix("dev", "linux", "x64")).toBe("dev-linux-x64");
+	});
+});
+
+describe("getTarballFileName", () => {
+	describe("macOS", () => {
+		it("uses .app.tar.gz extension", () => {
+			expect(getTarballFileName("MyApp", "macos")).toBe("MyApp.app.tar.gz");
+		});
+
+		it("preserves channel suffix in filename", () => {
+			expect(getTarballFileName("MyApp-canary", "macos")).toBe(
+				"MyApp-canary.app.tar.gz",
+			);
+		});
+	});
+
+	describe("Windows", () => {
+		it("uses .tar.gz extension", () => {
+			expect(getTarballFileName("MyApp", "win")).toBe("MyApp.tar.gz");
+		});
+
+		it("preserves channel suffix in filename", () => {
+			expect(getTarballFileName("MyApp-canary", "win")).toBe(
+				"MyApp-canary.tar.gz",
+			);
+		});
+	});
+
+	describe("Linux", () => {
+		it("uses .tar.gz extension", () => {
+			expect(getTarballFileName("MyApp", "linux")).toBe("MyApp.tar.gz");
+		});
+
+		it("preserves channel suffix in filename", () => {
+			expect(getTarballFileName("MyApp-canary", "linux")).toBe(
+				"MyApp-canary.tar.gz",
+			);
+		});
+	});
+});
+
+describe("getWindowsSetupFileName", () => {
+	it("returns AppName.exe for stable builds", () => {
+		expect(getWindowsSetupFileName("MyApp", "stable")).toBe("MyApp.exe");
+	});
+
+	it("includes channel suffix for canary builds", () => {
+		expect(getWindowsSetupFileName("MyApp", "canary")).toBe(
+			"MyApp-canary.exe",
+		);
+	});
+
+	it("includes channel suffix for dev builds", () => {
+		expect(getWindowsSetupFileName("MyApp", "dev")).toBe("MyApp-dev.exe");
+	});
+
+	it("preserves spaces in app name", () => {
+		expect(getWindowsSetupFileName("My App", "stable")).toBe(
+			"My App.exe",
+		);
+		expect(getWindowsSetupFileName("My App", "canary")).toBe(
+			"My App-canary.exe",
+		);
+	});
+});
+
+describe("getLinuxAppImageBaseName", () => {
+	it("returns AppName-Setup for stable builds", () => {
+		expect(getLinuxAppImageBaseName("MyApp", "stable")).toBe("MyApp-Setup");
+	});
+
+	it("includes channel suffix for canary builds", () => {
+		expect(getLinuxAppImageBaseName("MyApp", "canary")).toBe(
+			"MyApp-Setup-canary",
+		);
+	});
+
+	it("preserves spaces in app name", () => {
+		expect(getLinuxAppImageBaseName("My App", "stable")).toBe("My App-Setup");
+		expect(getLinuxAppImageBaseName("My App", "canary")).toBe(
+			"My App-Setup-canary",
+		);
+	});
+});
+
+describe("getLinuxAppImageFileName", () => {
+	it("returns full filename with .AppImage extension for stable", () => {
+		expect(getLinuxAppImageFileName("MyApp", "stable")).toBe(
+			"MyApp-Setup.AppImage",
+		);
+	});
+
+	it("returns full filename with .AppImage extension for canary", () => {
+		expect(getLinuxAppImageFileName("MyApp", "canary")).toBe(
+			"MyApp-Setup-canary.AppImage",
+		);
+	});
+
+	it("preserves spaces in app name", () => {
+		expect(getLinuxAppImageFileName("My App", "stable")).toBe(
+			"My App-Setup.AppImage",
+		);
+		expect(getLinuxAppImageFileName("My App", "canary")).toBe(
+			"My App-Setup-canary.AppImage",
+		);
+	});
+});
+
+describe("sanitizeVolumeNameForHdiutil", () => {
+	it("removes special characters", () => {
+		expect(sanitizeVolumeNameForHdiutil("My-App_v1.0")).toBe("MyAppv10");
+	});
+
+	it("removes parentheses and other punctuation", () => {
+		expect(sanitizeVolumeNameForHdiutil("My App (Beta)")).toBe("My App Beta");
+	});
+
+	it("preserves spaces and alphanumerics", () => {
+		expect(sanitizeVolumeNameForHdiutil("My App 2024")).toBe("My App 2024");
+	});
+
+	it("trims leading and trailing whitespace", () => {
+		expect(sanitizeVolumeNameForHdiutil("  My App  ")).toBe("My App");
+	});
+
+	it("handles names with only special characters", () => {
+		expect(sanitizeVolumeNameForHdiutil("---")).toBe("");
+	});
+});
+
+describe("getDmgVolumeName", () => {
+	it("returns plain name for stable builds", () => {
+		expect(getDmgVolumeName("MyApp", "stable")).toBe("MyApp");
+	});
+
+	it("adds channel suffix for non-stable builds", () => {
+		expect(getDmgVolumeName("MyApp", "canary")).toBe("MyApp-canary");
+	});
+
+	it("sanitizes special characters", () => {
+		expect(getDmgVolumeName("My-App", "stable")).toBe("MyApp");
+		expect(getDmgVolumeName("My-App", "canary")).toBe("MyApp-canary");
+	});
+});
+
+describe("URL construction functions", () => {
+	const baseUrl = "https://storage.example.com/releases";
+	const platformPrefix = "canary-macos-arm64";
+
+	describe("getUpdateInfoUrl", () => {
+		it("constructs correct flat URL with prefix", () => {
+			expect(getUpdateInfoUrl(baseUrl, platformPrefix)).toBe(
+				"https://storage.example.com/releases/canary-macos-arm64-update.json",
+			);
+		});
+
+		it("handles bucket URLs with trailing content", () => {
+			expect(
+				getUpdateInfoUrl("https://example.com/bucket", "stable-win-x64"),
+			).toBe("https://example.com/bucket/stable-win-x64-update.json");
+		});
+	});
+
+	describe("getPatchFileUrl", () => {
+		it("constructs correct flat URL with prefix and hash", () => {
+			expect(getPatchFileUrl(baseUrl, platformPrefix, "abc123def456")).toBe(
+				"https://storage.example.com/releases/canary-macos-arm64-abc123def456.patch",
+			);
+		});
+	});
+
+	describe("getTarballUrl", () => {
+		it("constructs correct flat URL for macOS tarball", () => {
+			expect(getTarballUrl(baseUrl, platformPrefix, "MyApp.app.tar.gz")).toBe(
+				"https://storage.example.com/releases/canary-macos-arm64-MyApp.app.tar.gz",
+			);
+		});
+
+		it("constructs correct flat URL for Windows tarball", () => {
+			expect(getTarballUrl(baseUrl, "stable-win-x64", "MyApp.tar.gz")).toBe(
+				"https://storage.example.com/releases/stable-win-x64-MyApp.tar.gz",
+			);
+		});
+	});
+});
+
+// Integration tests that verify CLI and Updater would produce matching values
+describe("CLI and Updater consistency", () => {
+	it("produces matching platform prefixes", () => {
+		// CLI uses: `${buildEnvironment}-${currentTarget.os}-${currentTarget.arch}`
+		// Updater uses: `${localInfo.channel}-${currentOS}-${currentArch}`
+		// Both should use getPlatformPrefix()
+		const cliResult = getPlatformPrefix("canary", "macos", "arm64");
+		const updaterResult = getPlatformPrefix("canary", "macos", "arm64");
+		expect(cliResult).toBe(updaterResult);
+		expect(cliResult).toBe("canary-macos-arm64");
+	});
+
+	it("produces matching tarball names for macOS", () => {
+		const appFileName = getAppFileName("My App", "canary");
+		const tarballName = getTarballFileName(appFileName, "macos");
+		expect(tarballName).toBe("MyApp-canary.app.tar.gz");
+	});
+
+	it("produces matching tarball names for Windows", () => {
+		const appFileName = getAppFileName("My App", "stable");
+		const tarballName = getTarballFileName(appFileName, "win");
+		expect(tarballName).toBe("MyApp.tar.gz");
+	});
+
+	it("produces matching tarball names for Linux", () => {
+		const appFileName = getAppFileName("My App", "dev");
+		const tarballName = getTarballFileName(appFileName, "linux");
+		expect(tarballName).toBe("MyApp-dev.tar.gz");
+	});
+
+	it("stable builds have no channel suffix in artifact names", () => {
+		// This is the regression test for the -stable bug
+		expect(getAppFileName("MyApp", "stable")).toBe("MyApp");
+		expect(getAppFileName("MyApp", "stable")).not.toContain("-stable");
+		expect(getTarballFileName(getAppFileName("MyApp", "stable"), "macos")).toBe(
+			"MyApp.app.tar.gz",
+		);
+		expect(getWindowsSetupFileName("MyApp", "stable")).toBe("MyApp.exe");
+		expect(getLinuxAppImageFileName("MyApp", "stable")).toBe(
+			"MyApp-Setup.AppImage",
+		);
+	});
+});

package/src/shared/naming.ts

@@ -0,0 +1,188 @@
+import type { SupportedOS, SupportedArch } from "./platform";
+
+/**
+ * Build environment/channel types.
+ * "stable" is special - it produces artifacts without a channel suffix.
+ */
+export type BuildEnvironment = "stable" | "canary" | "dev" | (string & {});
+
+/**
+ * Sanitizes an app name by removing spaces.
+ * Used as the base for all artifact naming.
+ */
+export function sanitizeAppName(appName: string): string {
+	return appName.replace(/ /g, "");
+}
+
+/**
+ * Generates the app file name based on build environment.
+ * Format: "AppName" (stable) or "AppName-channel" (non-stable)
+ *
+ * @example
+ * getAppFileName("My App", "stable") // "MyApp"
+ * getAppFileName("My App", "canary") // "MyApp-canary"
+ */
+export function getAppFileName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	const sanitized = sanitizeAppName(appName);
+	return buildEnvironment === "stable"
+		? sanitized
+		: `${sanitized}-${buildEnvironment}`;
+}
+
+/**
+ * Generates the macOS bundle display name (with spaces preserved).
+ * Used for the actual .app folder name on macOS.
+ * Format: "App Name" (stable) or "App Name-channel" (non-stable)
+ *
+ * @example
+ * getMacOSBundleDisplayName("My App", "stable") // "My App"
+ * getMacOSBundleDisplayName("My App", "canary") // "My App-canary"
+ */
+export function getMacOSBundleDisplayName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	return buildEnvironment === "stable"
+		? appName
+		: `${appName}-${buildEnvironment}`;
+}
+
+/**
+ * Generates the bundle file name (with platform-specific extension).
+ * macOS: "AppName.app" or "AppName-channel.app"
+ * Others: "AppName" or "AppName-channel"
+ */
+export function getBundleFileName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+	os: SupportedOS,
+): string {
+	const appFileName = getAppFileName(appName, buildEnvironment);
+	return os === "macos" ? `${appFileName}.app` : appFileName;
+}
+
+/**
+ * Generates the platform prefix for artifacts.
+ * Format: "channel-os-arch" (e.g., "stable-macos-arm64", "canary-win-x64")
+ * Used for flat file naming in artifact folders and bucket URLs.
+ */
+export function getPlatformPrefix(
+	buildEnvironment: BuildEnvironment,
+	os: SupportedOS,
+	arch: SupportedArch,
+): string {
+	return `${buildEnvironment}-${os}-${arch}`;
+}
+
+/**
+ * Generates the tarball file name for update distribution.
+ * macOS: "AppFileName.app.tar.gz"
+ * Others: "AppFileName.tar.gz"
+ */
+export function getTarballFileName(
+	appFileName: string,
+	os: SupportedOS,
+): string {
+	return os === "macos"
+		? `${appFileName}.app.tar.gz`
+		: `${appFileName}.tar.gz`;
+}
+
+/**
+ * Generates the Windows installer file name.
+ * Preserves spaces in app name for user-friendly display.
+ * Format: "App Name.exe" (stable) or "App Name-channel.exe" (non-stable)
+ */
+export function getWindowsSetupFileName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	return buildEnvironment === "stable"
+		? `${appName}.exe`
+		: `${appName}-${buildEnvironment}.exe`;
+}
+
+/**
+ * Generates the Linux AppImage wrapper name (without extension).
+ * Preserves spaces in app name for user-friendly display.
+ * Format: "App Name-Setup" (stable) or "App Name-Setup-channel" (non-stable)
+ */
+export function getLinuxAppImageBaseName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	return buildEnvironment === "stable"
+		? `${appName}-Setup`
+		: `${appName}-Setup-${buildEnvironment}`;
+}
+
+/**
+ * Generates the full Linux AppImage file name.
+ */
+export function getLinuxAppImageFileName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	return `${getLinuxAppImageBaseName(appName, buildEnvironment)}.AppImage`;
+}
+
+/**
+ * Sanitizes a volume name for hdiutil (macOS DMG creation).
+ * Removes all non-alphanumeric characters except spaces.
+ */
+export function sanitizeVolumeNameForHdiutil(name: string): string {
+	return name.replace(/[^a-zA-Z0-9 ]/g, "").trim();
+}
+
+/**
+ * Generates the DMG volume name for macOS.
+ * Takes the original app name (with spaces) and preserves them for display.
+ * Format: "App Name" (stable) or "App Name-channel" (non-stable)
+ */
+export function getDmgVolumeName(
+	appName: string,
+	buildEnvironment: BuildEnvironment,
+): string {
+	const baseName = sanitizeVolumeNameForHdiutil(appName);
+	return buildEnvironment === "stable"
+		? baseName
+		: `${baseName}-${buildEnvironment}`;
+}
+
+/**
+ * Constructs the full URL for the update.json file.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
+ */
+export function getUpdateInfoUrl(
+	baseUrl: string,
+	platformPrefix: string,
+): string {
+	return `${baseUrl.replace(/\/+$/, "")}/${platformPrefix}-update.json`;
+}
+
+/**
+ * Constructs the full URL for a patch file.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
+ */
+export function getPatchFileUrl(
+	baseUrl: string,
+	platformPrefix: string,
+	hash: string,
+): string {
+	return `${baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${hash}.patch`;
+}
+
+/**
+ * Constructs the full URL for a tarball.
+ * Uses flat prefix-based naming for compatibility with GitHub Releases and other hosts.
+ */
+export function getTarballUrl(
+	baseUrl: string,
+	platformPrefix: string,
+	tarballFileName: string,
+): string {
+	return `${baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${tarballFileName}`;
+}

package/src/shared/platform.ts

@@ -0,0 +1,48 @@
+import { platform, arch } from "os";
+
+export type SupportedOS = "macos" | "win" | "linux";
+export type SupportedArch = "arm64" | "x64";
+
+// Cache platform() result to avoid multiple system calls
+const platformName = platform();
+const archName = arch();
+
+// Determine OS once
+export const OS: SupportedOS = (() => {
+	switch (platformName) {
+		case "win32":
+			return "win";
+		case "darwin":
+			return "macos";
+		case "linux":
+			return "linux";
+		default:
+			throw new Error(`Unsupported platform: ${platformName}`);
+	}
+})();
+
+// Determine ARCH once, with Windows override
+export const ARCH: SupportedArch = (() => {
+	// Always use x64 for Windows since we only build x64 Windows binaries
+	if (OS === "win") {
+		return "x64";
+	}
+
+	switch (archName) {
+		case "arm64":
+			return "arm64";
+		case "x64":
+			return "x64";
+		default:
+			throw new Error(`Unsupported architecture: ${archName}`);
+	}
+})();
+
+// Export functions for backwards compatibility if needed
+export function getPlatformOS(): SupportedOS {
+	return OS;
+}
+
+export function getPlatformArch(): SupportedArch {
+	return ARCH;
+}