sparkbun 0.1.0

package/scripts/package-release.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env bun
+
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import process from "process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const platform = process.platform;
+const arch = process.arch;
+
+// Map Node.js platform/arch to our naming
+const platformMap = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "win",
+};
+
+const archMap = {
+	x64: "x64",
+	arm64: "arm64",
+};
+
+const platformName = platformMap[platform] || platform;
+// Always use x64 for Windows since we only build x64 Windows binaries
+const archName = platform === "win32" ? "x64" : archMap[arch] || arch;
+
+console.log(`Packaging Electrobun for ${platformName}-${archName}...`);
+
+// Build everything including CLI (no CI mode needed)
+console.log("Building full release...");
+try {
+	execSync("bun build.ts --release", { stdio: "inherit" });
+} catch (error) {
+	console.error("Build failed:", error.message);
+	process.exit(1);
+}
+
+// Generate template embeddings before building CLI
+console.log("Generating template embeddings...");
+const templatesDir = path.join(__dirname, "..", "..", "templates");
+const outputFile = path.join(
+	__dirname,
+	"..",
+	"src",
+	"cli",
+	"templates",
+	"embedded.ts",
+);
+
+// Ensure the templates directory exists for embedded.ts
+const templatesOutputDir = path.dirname(outputFile);
+if (!fs.existsSync(templatesOutputDir)) {
+	fs.mkdirSync(templatesOutputDir, { recursive: true });
+}
+
+// Verify that embedded.ts was created by build.ts, or create a minimal one
+if (!fs.existsSync(outputFile)) {
+	console.log("embedded.ts not found after build, creating minimal version...");
+	fs.writeFileSync(
+		outputFile,
+		`// Auto-generated template embeddings
+export const templates: Record<string, { name: string; files: Record<string, string> }> = {};
+
+export function getTemplate(name: string) {
+    return templates[name];
+}
+
+export function getTemplateNames(): string[] {
+    return Object.keys(templates);
+}
+`,
+	);
+} else {
+	// If templates exist, run the generation through build.ts
+	console.log("Templates found, generating embeddings...");
+	// This is already done by the build.ts --release command above
+}
+
+// Build CLI binary
+console.log("Building CLI binary...");
+if (!fs.existsSync("bin")) {
+	fs.mkdirSync("bin", { recursive: true });
+}
+
+// Use baseline target for Windows to ensure compatibility with ARM64 emulation
+const compileTarget =
+	platform === "win32" ? "--target=bun-windows-x64-baseline" : "";
+const vendoredBun = path.join(
+	"vendors",
+	"bun",
+	platform === "win32" ? "bun.exe" : "bun",
+);
+
+// Workaround for Windows 2025 runner cross-drive issues with Bun cache
+if (platform === "win32" && process.env.GITHUB_ACTIONS) {
+	// Set Bun cache to same drive as workspace
+	const workspaceDrive = process.cwd().substring(0, 2);
+	const bunCacheDir = `${workspaceDrive}\\temp\\bun-cache`;
+	console.log(`Setting BUN_INSTALL_CACHE_DIR to: ${bunCacheDir}`);
+
+	// Ensure cache directory exists
+	fs.mkdirSync(bunCacheDir, { recursive: true });
+
+	// Set environment variable directly in the command for Windows
+	execSync(
+		`set "BUN_INSTALL_CACHE_DIR=${bunCacheDir}" && "${vendoredBun}" build src/cli/index.ts --compile ${compileTarget} --outfile bin/electrobun`,
+		{ stdio: "inherit", shell: true },
+	);
+} else {
+	execSync(
+		`"${vendoredBun}" build src/cli/index.ts --compile ${compileTarget} --outfile bin/electrobun`,
+		{ stdio: "inherit" },
+	);
+}
+
+// Create separate tarballs for CLI, core binaries, and CEF
+const distPath = path.join(__dirname, "..", "dist");
+const cliOutputFile = path.join(
+	__dirname,
+	"..",
+	`electrobun-cli-${platformName}-${archName}.tar.gz`,
+);
+const coreOutputFile = path.join(
+	__dirname,
+	"..",
+	`electrobun-core-${platformName}-${archName}.tar.gz`,
+);
+const cefOutputFile = path.join(
+	__dirname,
+	"..",
+	`electrobun-cef-${platformName}-${archName}.tar.gz`,
+);
+
+console.log(`Creating CLI tarball: ${cliOutputFile}`);
+
+// Check if dist exists
+if (!fs.existsSync(distPath)) {
+	console.error("Error: dist directory not found");
+	process.exit(1);
+}
+
+// Create a tar.gz file using system tar (preserves file permissions)
+function createTarGz(tarGzPath, cwd, entries) {
+	execSync(
+		`tar -czf "${tarGzPath}" ${entries.map((e) => `"${e}"`).join(" ")}`,
+		{
+			cwd,
+			stdio: "pipe",
+		},
+	);
+}
+
+async function createTarballs() {
+	// Validate that we have platform-specific binaries, not just npm files
+	const expectedBinaries = [
+		platform === "win32" ? "electrobun.exe" : "electrobun",
+		platform === "win32" ? "bun.exe" : "bun",
+	];
+
+	const missingBinaries = expectedBinaries.filter(
+		(binary) => !fs.existsSync(path.join(distPath, binary)),
+	);
+
+	if (missingBinaries.length > 0) {
+		console.error(
+			`Error: Missing expected binaries in dist/: ${missingBinaries.join(", ")}`,
+		);
+		console.error("This suggests the build failed or was incomplete.");
+		console.error("Contents of dist/:");
+		if (fs.existsSync(distPath)) {
+			fs.readdirSync(distPath).forEach((file) => console.error(`  ${file}`));
+		} else {
+			console.error("  (dist directory does not exist)");
+		}
+		process.exit(1);
+	}
+
+	console.log("Validation passed: Found expected platform binaries in dist/");
+
+	// 1. Create CLI-only tarball
+	const binPath = path.join(__dirname, "..", "bin");
+	const cliSrc = path.join(
+		binPath,
+		"electrobun" + (platform === "win32" ? ".exe" : ""),
+	);
+
+	if (fs.existsSync(cliSrc)) {
+		console.log(`Creating CLI tarball: ${cliOutputFile}`);
+
+		// Create CLI tarball directly from bin directory (system tar preserves permissions)
+		createTarGz(cliOutputFile, binPath, [
+			"electrobun" + (platform === "win32" ? ".exe" : ""),
+		]);
+
+		const cliStats = fs.statSync(cliOutputFile);
+		const cliSizeMB = (cliStats.size / 1024 / 1024).toFixed(2);
+		console.log(`CLI tarball size: ${cliSizeMB} MB`);
+	}
+
+	// 2. Create core binaries tarball (exclude CEF and CLI)
+	const coreFiles = fs
+		.readdirSync(distPath)
+		.filter((file) => file !== "cef" && !file.startsWith("electrobun"));
+
+	if (coreFiles.length > 0) {
+		console.log(`Creating core binaries tarball: ${coreOutputFile}`);
+
+		createTarGz(coreOutputFile, distPath, coreFiles);
+
+		const coreStats = fs.statSync(coreOutputFile);
+		const coreSizeMB = (coreStats.size / 1024 / 1024).toFixed(2);
+		console.log(`Core binaries tarball size: ${coreSizeMB} MB`);
+	}
+
+	// 3. Create CEF tarball if CEF directory exists
+	const cefPath = path.join(distPath, "cef");
+	if (fs.existsSync(cefPath)) {
+		console.log(`Creating CEF tarball: ${cefOutputFile}`);
+
+		createTarGz(cefOutputFile, distPath, ["cef"]);
+
+		const cefStats = fs.statSync(cefOutputFile);
+		const cefSizeMB = (cefStats.size / 1024 / 1024).toFixed(2);
+		console.log(`CEF tarball size: ${cefSizeMB} MB`);
+	} else {
+		console.log("No CEF directory found, skipping CEF tarball");
+	}
+}
+
+createTarballs().catch((err) => {
+	console.error("Error creating tarballs:", err);
+	process.exit(1);
+});

package/scripts/push-version.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env bun
+/**
+ * Version bump, commit, tag, and push script
+ *
+ * Usage: bun scripts/push-version.js <type>
+ *
+ * Types:
+ *   beta   - prerelease bump (0.5.0-beta.0 -> 0.5.0-beta.1)
+ *   patch  - prepatch bump (0.5.0-beta.0 -> 0.5.1-beta.0)
+ *   minor  - preminor bump (0.5.0-beta.0 -> 0.6.0-beta.0)
+ *   major  - premajor bump (0.5.0-beta.0 -> 1.0.0-beta.0)
+ *   stable - patch bump without beta (0.5.0 -> 0.5.1)
+ */
+
+import { execSync } from "child_process";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const type = process.argv[2];
+
+if (!type || !["beta", "patch", "minor", "major", "stable"].includes(type)) {
+	console.error(
+		"Usage: bun scripts/push-version.js <beta|patch|minor|major|stable>",
+	);
+	process.exit(1);
+}
+
+const packageDir = import.meta.dir.replace("/scripts", "");
+const repoRoot = join(packageDir, "..");
+const packageJsonPath = join(packageDir, "package.json");
+
+// Read current version
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+const currentVersion = packageJson.version;
+
+// Determine npm version command
+const versionCmd = {
+	beta: "prerelease --preid=beta",
+	patch: "prepatch --preid=beta",
+	minor: "preminor --preid=beta",
+	major: "premajor --preid=beta",
+	stable: "patch",
+}[type];
+
+console.log(`Current version: ${currentVersion}`);
+console.log(`Running: npm version ${versionCmd}`);
+
+// Bump version (without git operations)
+execSync(`npm version ${versionCmd} --no-git-tag-version`, {
+	cwd: packageDir,
+	stdio: "inherit",
+});
+
+// Read new version
+const updatedPackageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+const newVersion = updatedPackageJson.version;
+const tagName = `v${newVersion}`;
+
+console.log(`New version: ${newVersion}`);
+
+// Update kitchen sink version to match
+const kitchenConfigPath = join(repoRoot, "kitchen", "electrobun.config.ts");
+let kitchenConfig = readFileSync(kitchenConfigPath, "utf-8");
+kitchenConfig = kitchenConfig.replace(
+	/version:\s*["'].*["']/,
+	`version: "${newVersion}"`,
+);
+writeFileSync(kitchenConfigPath, kitchenConfig);
+console.log(`Updated kitchen/electrobun.config.ts version to ${newVersion}`);
+
+// Git operations from repo root
+console.log(`Creating commit and tag: ${tagName}`);
+
+execSync(`git add package/package.json kitchen/electrobun.config.ts`, {
+	cwd: repoRoot,
+	stdio: "inherit",
+});
+execSync(`git commit -m "${tagName}"`, { cwd: repoRoot, stdio: "inherit" });
+execSync(`git tag ${tagName}`, { cwd: repoRoot, stdio: "inherit" });
+
+console.log(`Pushing to origin...`);
+execSync(`git push origin main --tags`, { cwd: repoRoot, stdio: "inherit" });
+
+console.log(`\n✓ Successfully pushed ${tagName}`);

package/scripts/update-bun-version.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+
+/**
+ * Checks GitHub for the latest stable Bun release and compares it
+ * with the version in src/shared/bun-version.ts.
+ *
+ * When a newer version exists:
+ *   - Overwrites src/shared/bun-version.ts with the new version
+ *   - Sets has_update=true in $GITHUB_OUTPUT
+ *
+ * Always outputs version info to $GITHUB_OUTPUT and a human-readable
+ * summary to $GITHUB_STEP_SUMMARY.
+ */
+
+import { BUN_VERSION } from "../src/shared/bun-version";
+import { appendFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+const BUN_RELEASES_URL =
+	"https://api.github.com/repos/oven-sh/bun/releases/latest";
+
+async function getLatestStableBunVersion(): Promise<string> {
+	const headers: Record<string, string> = {
+		Accept: "application/vnd.github+json",
+		"X-GitHub-Api-Version": "2022-11-28",
+	};
+	const token = process.env["GITHUB_TOKEN"];
+	if (token) {
+		headers["Authorization"] = `Bearer ${token}`;
+	}
+
+	const response = await fetch(BUN_RELEASES_URL, { headers });
+	if (!response.ok) {
+		throw new Error(
+			`Failed to fetch Bun latest release: HTTP ${response.status}`,
+		);
+	}
+
+	const data = (await response.json()) as { tag_name?: string };
+	if (!data.tag_name) {
+		throw new Error("No tag_name in Bun latest release response");
+	}
+
+	// Bun release tags look like "bun-v1.3.11" — strip the prefix.
+	const match = /^bun-v(.+)$/.exec(data.tag_name);
+	if (!match) {
+		throw new Error(`Unexpected Bun release tag format: ${data.tag_name}`);
+	}
+
+	return match[1]!;
+}
+
+function setOutput(key: string, value: string) {
+	const outputFile = process.env["GITHUB_OUTPUT"];
+	if (outputFile) {
+		appendFileSync(outputFile, `${key}=${value}\n`);
+	}
+}
+
+function writeSummary(markdown: string) {
+	const summaryFile = process.env["GITHUB_STEP_SUMMARY"];
+	if (summaryFile) {
+		appendFileSync(summaryFile, markdown + "\n");
+	}
+}
+
+async function main() {
+	const currentBun = BUN_VERSION;
+	console.log(`Current:  Bun ${currentBun}`);
+
+	const latest = await getLatestStableBunVersion();
+	console.log(`Latest:   Bun ${latest}`);
+
+	const hasUpdate = currentBun !== latest;
+
+	setOutput("current_bun_version", currentBun);
+	setOutput("latest_bun_version", latest);
+	setOutput("has_update", hasUpdate ? "true" : "false");
+
+	if (hasUpdate) {
+		console.log("Version mismatch — updating src/shared/bun-version.ts");
+
+		const bunVersionPath = resolve(
+			import.meta.dir,
+			"../src/shared/bun-version.ts",
+		);
+		const newContent = [
+			"// Default Bun version shipped with this Electrobun release.",
+			"// All platforms use the same version. Update this when bumping Bun.",
+			`export const BUN_VERSION = "${latest}";`,
+			"",
+		].join("\n");
+		writeFileSync(bunVersionPath, newContent);
+		console.log(`Wrote ${bunVersionPath}`);
+	} else {
+		console.log("Bun version is up to date.");
+	}
+
+	const summary = hasUpdate
+		? [
+				"## Bun Compatibility Check",
+				"",
+				`| | Bun |`,
+				`|---|---|`,
+				`| **Current** | \`${currentBun}\` |`,
+				`| **Latest** | \`${latest}\` |`,
+				"",
+				"New version detected — build step will run.",
+			].join("\n")
+		: [
+				"## Bun Compatibility Check",
+				"",
+				`Bun \`${currentBun}\` is the latest stable version. No build needed.`,
+			].join("\n");
+
+	writeSummary(summary);
+}
+
+main().catch((err) => {
+	console.error("Error checking Bun version:", err);
+	process.exit(1);
+});

package/scripts/update-cef-version.ts

@@ -0,0 +1,145 @@
+#!/usr/bin/env bun
+
+/**
+ * Checks Spotify CDN for the latest stable CEF version and compares it
+ * with the version in src/shared/cef-version.ts.
+ *
+ * When a newer version exists:
+ *   - Overwrites src/shared/cef-version.ts with the new version pair
+ *   - Sets has_update=true in $GITHUB_OUTPUT
+ *
+ * Always outputs version info to $GITHUB_OUTPUT and a human-readable
+ * summary to $GITHUB_STEP_SUMMARY.
+ */
+
+import { CEF_VERSION, CHROMIUM_VERSION } from "../src/shared/cef-version";
+import { appendFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+const CEF_INDEX_URL =
+	"https://cef-builds.spotifycdn.com/index.json";
+
+interface StableVersion {
+	cef_version: string;
+	chromium_version: string;
+}
+
+async function getLatestStableCEFVersion(): Promise<StableVersion> {
+	const response = await fetch(CEF_INDEX_URL);
+	if (!response.ok) {
+		throw new Error(
+			`Failed to fetch CEF builds index: HTTP ${response.status}`,
+		);
+	}
+
+	const data = (await response.json()) as {
+		linux64: {
+			versions: Array<{
+				cef_version: string;
+				chromium_version: string;
+				channel: string;
+			}>;
+		};
+	};
+
+	const versions = data.linux64?.versions;
+	if (!versions || versions.length === 0) {
+		throw new Error("No versions found in CEF builds index");
+	}
+
+	const stable = versions.find((v) => v.channel === "stable");
+	if (!stable) {
+		throw new Error("No stable CEF version found in builds index");
+	}
+
+	// The CDN's cef_version includes "+chromium-..." suffix, but cef-version.ts
+	// stores just the CEF part (e.g. "144.0.11+ge135be2").
+	const cefOnly = stable.cef_version.replace(/\+chromium-.*$/, "");
+
+	return {
+		cef_version: cefOnly,
+		chromium_version: stable.chromium_version,
+	};
+}
+
+function setOutput(key: string, value: string) {
+	const outputFile = process.env.GITHUB_OUTPUT;
+	if (outputFile) {
+		appendFileSync(outputFile, `${key}=${value}\n`);
+	}
+}
+
+function writeSummary(markdown: string) {
+	const summaryFile = process.env.GITHUB_STEP_SUMMARY;
+	if (summaryFile) {
+		appendFileSync(summaryFile, markdown + "\n");
+	}
+}
+
+async function main() {
+	const currentCef = CEF_VERSION;
+	const currentChromium = CHROMIUM_VERSION;
+	console.log(`Current:  CEF ${currentCef}  Chromium ${currentChromium}`);
+
+	const latest = await getLatestStableCEFVersion();
+	console.log(
+		`Latest:   CEF ${latest.cef_version}  Chromium ${latest.chromium_version}`,
+	);
+
+	const hasUpdate =
+		currentCef !== latest.cef_version ||
+		currentChromium !== latest.chromium_version;
+
+	// Always emit version outputs
+	setOutput("current_cef_version", currentCef);
+	setOutput("current_chromium_version", currentChromium);
+	setOutput("latest_cef_version", latest.cef_version);
+	setOutput("latest_chromium_version", latest.chromium_version);
+	setOutput("has_update", hasUpdate ? "true" : "false");
+
+	if (hasUpdate) {
+		console.log("Version mismatch — updating src/shared/cef-version.ts");
+
+		const cefVersionPath = resolve(
+			import.meta.dir,
+			"../src/shared/cef-version.ts",
+		);
+		const newContent = [
+			"// Default CEF version shipped with this Electrobun release.",
+			"// All platforms use the same version. Update this single pair when bumping CEF.",
+			`export const CEF_VERSION = \`${latest.cef_version}\`;`,
+			`export const CHROMIUM_VERSION = \`${latest.chromium_version}\`;`,
+			"export const DEFAULT_CEF_VERSION_STRING = `${CEF_VERSION}+chromium-${CHROMIUM_VERSION}`;",
+			"",
+		].join("\n");
+		writeFileSync(cefVersionPath, newContent);
+		console.log(`Wrote ${cefVersionPath}`);
+	} else {
+		console.log("CEF version is up to date.");
+	}
+
+	// Step summary
+	const summary = hasUpdate
+		? [
+				"## CEF Compatibility Check",
+				"",
+				`| | CEF | Chromium |`,
+				`|---|---|---|`,
+				`| **Current** | \`${currentCef}\` | \`${currentChromium}\` |`,
+				`| **Latest** | \`${latest.cef_version}\` | \`${latest.chromium_version}\` |`,
+				"",
+				"New version detected — build step will run.",
+			].join("\n")
+		: [
+				"## CEF Compatibility Check",
+				"",
+				`CEF \`${currentCef}\` is the latest stable version. No build needed.`,
+			].join("\n");
+
+	writeSummary(summary);
+}
+
+main().catch((err) => {
+	console.error("Error checking CEF version:", err);
+	process.exit(1);
+});

package/src/browser/builtinrpcSchema.ts

@@ -0,0 +1,19 @@
+// consider just makeing a shared types file
+
+export type BuiltinBunToWebviewSchema = {
+	requests: {
+		evaluateJavascriptWithResponse: {
+			params: { script: string };
+			response: any;
+		};
+	};
+};
+
+export type BuiltinWebviewToBunSchema = {
+	requests: {
+		webviewTagInit: {
+			params: {};
+			response: any;
+		};
+	};
+};

package/src/browser/global.d.ts

@@ -0,0 +1,36 @@
+// Global type declarations for SparkBun browser environment
+
+interface SparkBunEncryptResult {
+  encryptedData: string;
+  iv: string;
+  tag: string;
+}
+
+interface SparkBunBridge {
+  receiveMessageFromHost: (msg: unknown) => void;
+  receiveInternalMessageFromHost: (msg: unknown) => void;
+  receiveMessageFromBun: (msg: unknown) => void;
+  receiveInternalMessageFromBun: (msg: unknown) => void;
+}
+
+interface MessageHandler {
+  postMessage: (msg: string) => void;
+}
+
+declare global {
+  interface Window {
+    __sparkbunWebviewId: number;
+    __sparkbunWindowId: number;
+    __sparkbunRpcSocketPort: number;
+    __sparkbunHostSocketPort?: number;
+    __sparkbun?: SparkBunBridge;
+    __sparkbunPendingHostMessages?: unknown[];
+    __sparkbun_encrypt: (msg: string) => Promise<SparkBunEncryptResult>;
+    __sparkbun_decrypt: (encryptedData: string, iv: string, tag: string) => Promise<string>;
+    __sparkbunInternalBridge?: MessageHandler;
+    __sparkbunHostBridge?: MessageHandler;
+    __sparkbunBunBridge?: MessageHandler;
+  }
+}
+
+export {};