electrobun 1.16.0 → 1.17.0-beta.0

package/README.md

@@ -27,9 +27,43 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 - Provide everything you need in one tightly integrated workflow to start writing code in 5 minutes and distribute in 10.
 
 ## Apps Built with Electrobun
+- [24agents](https://github.com/jhsu/24agents) - Hyperprompter
+- [act-track-ai](https://github.com/IrdanGu/act-track-ai) - personal desktop productivity tracker
+- [Agents Council](https://github.com/MrLesk/agents-council) - agent-to-agent MCP communication tool for feedback requests
+- [ai-wrapped](https://github.com/gulivan/ai-wrapped) - Wrapped-style desktop dashboard for your AI coding agent activity
 - [Audio TTS](https://github.com/blackboardsh/audio-tts) - desktop text-to-speech app using Qwen3-TTS for voice design, cloning, and generation
+- [aueio-player-desktop](https://github.com/tuomashatakka/aueio-player-desktop) - beautiful, minimal cross-platform audio player
+- [bestdiff](https://github.com/tesmond/bestdiff) - a git diff checker with curved connectors
+- [BuddyWriter](https://github.com/OxFrancesco/BuddyWriter) - BuddyWriter desktop and mobile apps
+- [burns](https://github.com/l3wi/burns) - a Smithers manager
+- [cbx-tool](https://github.com/jebin2/cbx-tool) - desktop app for reading and editing comic book archives (.cbz/.cbr)
 - [Co(lab)](https://blackboard.sh/colab/) - a hybrid web browser + code editor for deep work
+- [codlogs](https://github.com/tobitege/codlogs) - search and export local Codex sessions via CLI or desktop app
+- [Codex Agents Composer](https://github.com/MrLesk/codex-agents-composer) - desktop app for managing your Codex agents and their skills
+- [codex-devtools](https://github.com/gulivan/codex-devtools) - desktop inspector for Codex session data; browse conversations, search messages, and analyze agent activity
+- [Deskdown](https://github.com/guarana-studio/deskdown) - transform any web address into a desktop app in under 20 seconds
+- [dev-3.0](https://github.com/h0x91b/dev-3.0) - helps you not get lost while managing multiple AI agents across projects
 - [DOOM](https://github.com/blackboardsh/electrobun-doom) - DOOM implemented in 2 ways: bun -> (c doom -> bundled wgpu) and (full ts port bun -> bundled wgpu)
+- [electrobun-rms](https://github.com/khanhthanhdev/electrobun-rms) - fast Electrobun desktop app template with React, Tailwind CSS, and Vite
+- [golb](https://github.com/chrisdadev13/golb) - desktop AI coding workspace built with React, Vite, and Tailwind
+- [GOG Achievements GUI](https://github.com/timendum/gog-achievements-gui) - desktop app for managing GOG achievements
+- [groov](https://github.com/laurenzcodes/groov) - desktop audio deck monitor
+- [Guerilla Glass](https://github.com/okikeSolutions/guerillaglass) - open-source cross-platform creator studio for fast Record -> Edit -> Deliver workflows
+- [Marginalia](https://github.com/lars-hoeijmans/Marginalia) - a simple note taking app
+- [md-browse](https://github.com/needle-tools/md-browse) - a markdown-first browser that converts web pages to clean markdown
+- [peekachu](https://github.com/needle-tools/peekachu) - password manager for AIs; store secrets in your OS keychain and scrub output so AI assistants never see actual values
+- [PLEXI](https://github.com/ianjamesburke/PLEXI) - a multi-dimensional terminal multiplexer for the agentic era
+- [Prometheus](https://github.com/opensourcectl/prometheus) - desktop utility toolbox for file cleanup, document manipulation, and image processing
+- [Quiver](https://ataraxy-labs.github.io/quiver/) - desktop app for GitHub PR reviews, merge conflict resolution, and AI commit messages
+- [remotecode.io](https://github.com/samuelfaj/remotecode.io) - continue local AI coding sessions (Claude Code or Codex) from your mobile device
+- [sirene](https://github.com/KevinBonnoron/sirene) - self-hosted multi-backend text-to-speech platform with voice cloning
+- [StoryForge](https://github.com/vrrdnt/StoryForge) - desktop app for Vintage Story players to switch between game versions, modpacks, servers, and accounts
+- [Tensamin Client](https://github.com/Tensamin/Client) - web, desktop, and mobile app for accessing Tensamin
+- [tokenpass-desktop](https://github.com/b-open-io/tokenpass-desktop) - desktop app that runs the Sigma Identity stack locally for Bitcoin-backed authentication
+- [typsmthng-desktop](https://github.com/aaditagrawal/typsmthng-desktop) - experimental desktop typing application
+- [VibesOS](https://github.com/popmechanic/VibesOS) - A GUI for Claude Code that makes it easy to vibe code simple, un-hackable apps
+- [VoiceVault](https://github.com/PJH720/VoiceVault) - AI-powered voice recorder with transcription, summarization, and RAG search
+- [warren](https://github.com/Loa212/warren) - open-source, peer-to-peer terminal mesh for accessing your machines from any device without SSH keys or config files
 
 ### Video Demos
 
@@ -41,12 +75,12 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 
 ## Star History
 
-[![Star History Chart](https://api.star-history.com/svg?repos=blackboardsh/electrobun&type=date&legend=top-left&cache=2)](https://www.star-history.com/#blackboardsh/electrobun&type=date&legend=top-left)
+[![Star History Chart](https://api.star-history.com/svg?repos=blackboardsh/electrobun&type=date&legend=top-left&cache=3)](https://www.star-history.com/#blackboardsh/electrobun&type=date&legend=top-left)
 
 ## Contributing
 Ways to get involved:
 
-- Follow us on X for updates <a href="https://twitter.com/BlackboardTech">@BlackboardTech</a> or <a href="https://bsky.app/profile/yoav.codes">@yoav.codes</a>
+- Follow us on X for updates <a href="https://twitter.com/BlackboardTech">@BlackboardTech</a> and <a href="https://twitter.com/YoavCodes">@YoavCodes</a> or on bluesky <a href="https://bsky.app/profile/yoav.codes">@yoav.codes</a>
 - Join the conversation on <a href="https://discord.gg/ueKE4tjaCE">Discord</a>
 - Create and participate in Github issues and discussions
 - Let me know what you're building with Electrobun

package/dist/api/bun/ElectrobunConfig.ts

@@ -198,6 +198,22 @@ export interface ElectrobunConfig {
 		 */
 		watchIgnore?: string[];
 
+		/**
+		 * Carrot build configuration.
+		 * When present, the build also produces a carrot artifact alongside the standalone app.
+		 * Set `carrotOnly: true` to skip the standalone app build entirely.
+		 */
+		carrot?: {
+			id: string;
+			name: string;
+			description?: string;
+			mode?: "window" | "background";
+			carrotOnly?: boolean;
+			permissions?: Record<string, unknown>;
+			dependencies?: Record<string, string>;
+			remoteUIs?: Record<string, { entrypoint: string; [key: string]: unknown }>;
+		};
+
 		/**
 		 * macOS-specific build configuration
 		 */

package/dist/api/bun/core/BrowserView.ts

@@ -9,7 +9,11 @@ import {
 } from "../../shared/rpc.js";
 import { Updater } from "./Updater";
 import { BuildConfig } from "./BuildConfig";
-import { rpcPort, sendMessageToWebviewViaSocket } from "./Socket";
+import {
+	rpcPort,
+	sendMessageToWebviewViaSocket,
+	removeSocketForWebview,
+} from "./Socket";
 import { randomBytes } from "crypto";
 import { type Pointer } from "bun:ffi";
 
@@ -102,6 +106,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	sandbox: boolean = false;
 	startTransparent: boolean = false;
 	startPassthrough: boolean = false;
+	isRemoved: boolean = false;
 
 	constructor(options: Partial<BrowserViewOptions<T>> = defaultOptions) {
 		// const rpc = options.rpc;
@@ -211,13 +216,16 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	// so we have to chunk it
 	// TODO: is this still needed after switching from named pipes
 	executeJavascript(js: string) {
+		if (!this.ptr || this.isRemoved) {
+			return;
+		}
 		ffi.request.evaluateJavascriptWithNoCompletion({ id: this.id, js });
 	}
 
 	loadURL(url: string) {
 		console.log(`DEBUG: loadURL called for webview ${this.id}: ${url}`);
 		this.url = url;
-		native.symbols.loadURLInWebView(this.ptr, toCString(this.url));
+		native!.symbols.loadURLInWebView(this.ptr, toCString(this.url));
 	}
 
 	loadHTML(html: string) {
@@ -229,18 +237,18 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 
 		if (this.renderer === "cef") {
 			// For CEF, store HTML content in native map and use scheme handler
-			native.symbols.setWebviewHTMLContent(this.id, toCString(html));
+			native!.symbols.setWebviewHTMLContent(this.id, toCString(html));
 			this.loadURL("views://internal/index.html");
 		} else {
 			// For WKWebView, load HTML content directly
-			native.symbols.loadHTMLInWebView(this.ptr, toCString(html));
+			native!.symbols.loadHTMLInWebView(this.ptr, toCString(html));
 		}
 	}
 
 	setNavigationRules(rules: string[]) {
 		this.navigationRules = JSON.stringify(rules);
 		const rulesJson = JSON.stringify(rules);
-		native.symbols.setWebviewNavigationRules(this.ptr, toCString(rulesJson));
+		native!.symbols.setWebviewNavigationRules(this.ptr, toCString(rulesJson));
 	}
 
 	findInPage(
@@ -249,7 +257,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	) {
 		const forward = options?.forward ?? true;
 		const matchCase = options?.matchCase ?? false;
-		native.symbols.webviewFindInPage(
+		native!.symbols.webviewFindInPage(
 			this.ptr,
 			toCString(searchText),
 			forward,
@@ -258,19 +266,19 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	}
 
 	stopFindInPage() {
-		native.symbols.webviewStopFind(this.ptr);
+		native!.symbols.webviewStopFind(this.ptr);
 	}
 
 	openDevTools() {
-		native.symbols.webviewOpenDevTools(this.ptr);
+		native!.symbols.webviewOpenDevTools(this.ptr);
 	}
 
 	closeDevTools() {
-		native.symbols.webviewCloseDevTools(this.ptr);
+		native!.symbols.webviewCloseDevTools(this.ptr);
 	}
 
 	toggleDevTools() {
-		native.symbols.webviewToggleDevTools(this.ptr);
+		native!.symbols.webviewToggleDevTools(this.ptr);
 	}
 
 	/**
@@ -278,7 +286,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	 * @param zoomLevel - The zoom level (1.0 = 100%, 1.5 = 150%, etc.)
 	 */
 	setPageZoom(zoomLevel: number) {
-		native.symbols.webviewSetPageZoom(this.ptr, zoomLevel);
+		native!.symbols.webviewSetPageZoom(this.ptr, zoomLevel);
 	}
 
 	/**
@@ -286,7 +294,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	 * @returns The current zoom level (1.0 = 100%)
 	 */
 	getPageZoom(): number {
-		return native.symbols.webviewGetPageZoom(this.ptr) as number;
+		return native!.symbols.webviewGetPageZoom(this.ptr) as number;
 	}
 
 	// todo (yoav): move this to a class that also has off, append, prepend, etc.
@@ -315,6 +323,9 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 
 		return {
 			send(message: any) {
+				if (!that.ptr || that.isRemoved) {
+					return;
+				}
 				const sentOverSocket = sendMessageToWebviewViaSocket(that.id, message);
 
 				if (!sentOverSocket) {
@@ -327,14 +338,31 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 				}
 			},
 			registerHandler(handler: (msg: unknown) => void) {
+				if (that.isRemoved) {
+					return;
+				}
 				that.rpcHandler = handler;
 			},
 		};
 	};
 
 	remove() {
-		native.symbols.webviewRemove(this.ptr);
+		if (!this.ptr || this.isRemoved) {
+			return;
+		}
+		const ptr = this.ptr;
+		this.isRemoved = true;
+		// Drop JS-side references first so late callbacks cannot target a stale view.
 		delete BrowserViewMap[this.id];
+		removeSocketForWebview(this.id);
+		this.rpc?.setTransport({
+			send() {},
+			registerHandler() {},
+			unregisterHandler() {},
+		});
+		this.rpcHandler = undefined;
+		this.ptr = null as any;
+		native!.symbols.webviewRemove(ptr);
 	}
 
 	static getById(id: number) {

package/dist/api/bun/core/Socket.ts

@@ -47,6 +47,14 @@ export const socketMap: {
 	};
 } = {};
 
+export const removeSocketForWebview = (webviewId: number) => {
+	const rpc = socketMap[webviewId];
+	if (!rpc) return;
+
+	rpc.socket = null;
+	delete socketMap[webviewId];
+};
+
 const startRPCServer = () => {
 	const startPort = 50000;
 	const endPort = 65535;

package/dist/api/bun/core/Updater.ts

@@ -1119,11 +1119,9 @@ del "%~f0"
 			localInfo = await Bun.file(`../${resourcesDir}/version.json`).json();
 			return localInfo;
 		} catch (error) {
-			// Handle the error
 			console.error("Failed to read version.json", error);
-
-			// Then rethrow so the app crashes
-			throw error;
+			localInfo = { identifier: "", channel: "", version: "", hash: "", baseUrl: "", name: "" };
+			return localInfo;
 		}
 	},
 };

package/dist/api/bun/core/Utils.ts

@@ -136,25 +136,27 @@ export const quit = () => {
 		return;
 	}
 
-	// Phase 1: Signal the native event loop to stop
-	native.symbols.stopEventLoop();
-	// Phase 2: Wait for native shutdown to complete (CefShutdown etc.)
-	// This blocks the worker thread until the main thread finishes cleanup.
-	native.symbols.waitForShutdownComplete(5000);
-	// Phase 3: Now safe to exit - CEF is fully shut down.
-	// Use _exit() via forceExit to guarantee termination. process.exit() from
-	// a Worker thread can fail to terminate when the main thread is blocked in FFI.
-	native.symbols.forceExit(0);
+	if (native) {
+		native.symbols.stopEventLoop();
+		native.symbols.waitForShutdownComplete(5000);
+		native.symbols.forceExit(0);
+	} else {
+		process.exit(0);
+	}
 };
 
 // Override process.exit so that calling it triggers proper native cleanup
+const _originalProcessExit = process.exit;
 process.exit = ((code?: number) => {
-	if (isQuitting) {
-		// Already in quit sequence — force-terminate immediately
-		native.symbols.forceExit(code ?? 0);
-		return;
+	if (native) {
+		if (isQuitting) {
+			native.symbols.forceExit(code ?? 0);
+			return;
+		}
+		quit();
+	} else {
+		_originalProcessExit(code ?? 0);
 	}
-	quit();
 }) as typeof process.exit;
 
 export const openFileDialog = async (
@@ -358,7 +360,8 @@ function getVersionInfo(): { identifier: string; channel: string } {
 		return _versionInfo;
 	} catch (error) {
 		console.error("Failed to read version.json", error);
-		throw error;
+		_versionInfo = { identifier: "", channel: "" };
+		return _versionInfo;
 	}
 }
 

package/dist/api/bun/index.ts

@@ -44,6 +44,143 @@ import type {
 	ApplicationMenuItemConfig,
 } from "./proc/native";
 import { BuildConfig, type BuildConfigType } from "./core/BuildConfig";
+import { bridge, hasFFI } from "./proc/native";
+
+// Carrot boot state — populated from __bunnyCarrotBootstrap injected by Bunny Ears
+let _carrotManifest: Record<string, unknown> | null = null;
+let _carrotContext: { currentDir?: string; statePath?: string; logsPath?: string; permissions?: string[]; grantedPermissions?: Record<string, unknown>; authToken?: string | null; channel?: string } | null = null;
+
+const _bootstrap = (globalThis as any).__bunnyCarrotBootstrap as { manifest?: any; context?: any } | undefined;
+if (_bootstrap) {
+	_carrotManifest = _bootstrap.manifest ?? null;
+	_carrotContext = _bootstrap.context ?? null;
+}
+
+if (bridge) {
+	bridge.on("init", (payload: any) => {
+		if (payload?.manifest) _carrotManifest = payload.manifest;
+		if (payload?.context) _carrotContext = payload.context;
+	});
+
+	// Forward host events to the local event emitter so ApplicationMenu.on(),
+	// ContextMenu.on(), etc. work in carrot workers
+	for (const eventName of ["application-menu-clicked", "context-menu-clicked"]) {
+		bridge.on(eventName, (payload: unknown) => {
+			electobunEventEmmitter.emitEvent({ type: eventName, data: payload } as any);
+		});
+	}
+
+	// Update local auth token when the host notifies of a change (e.g., Farm login)
+	bridge.on("auth-token-changed", (payload: unknown) => {
+		const token = (payload as any)?.token;
+		if (token && _carrotContext) {
+			_carrotContext.authToken = token;
+		}
+	});
+
+	// Clear local auth token on logout
+	bridge.on("auth-token-cleared", () => {
+		if (_carrotContext) {
+			_carrotContext.authToken = null;
+		}
+	});
+}
+
+export const Carrots = {
+	async invoke<T = unknown>(
+		carrotId: string,
+		method: string,
+		params?: unknown,
+		options?: { windowId?: string },
+	): Promise<T> {
+		if (!bridge) throw new Error("Carrots.invoke() is only available when running as a carrot inside Bunny Ears");
+		return bridge.requestHost<T>("invoke-carrot", { carrotId, method, params, windowId: options?.windowId });
+	},
+	emit(carrotId: string, name: string, payload?: unknown) {
+		if (!bridge) throw new Error("Carrots.emit() is only available when running as a carrot inside Bunny Ears");
+		bridge.sendAction("emit-carrot-event", { carrotId, name, payload });
+	},
+	async list() {
+		if (!bridge) throw new Error("Carrots.list() is only available when running as a carrot inside Bunny Ears");
+		return bridge.requestHost<Array<{
+			id: string; name: string; description: string; version: string;
+			mode: string; permissions: string[]; status: string; devMode: boolean;
+		}>>("list-carrots");
+	},
+	async start(carrotId: string) {
+		if (!bridge) throw new Error("Carrots.start() is only available when running as a carrot inside Bunny Ears");
+		return bridge.requestHost<{ ok: boolean }>("start-carrot", { id: carrotId });
+	},
+	async stop(carrotId: string) {
+		if (!bridge) throw new Error("Carrots.stop() is only available when running as a carrot inside Bunny Ears");
+		return bridge.requestHost<{ ok: boolean }>("stop-carrot", { id: carrotId });
+	},
+};
+
+export const app = {
+	on(name: string, handler: (payload: unknown) => void) {
+		if (bridge) {
+			return bridge.on(name, handler);
+		}
+		electobunEventEmmitter.on(name, (e: { data: unknown }) => handler(e.data));
+		return () => {};
+	},
+	quit() {
+		Utils.quit();
+	},
+	get isCarrotMode() {
+		return !hasFFI;
+	},
+	get manifest() {
+		return _carrotManifest;
+	},
+	get permissions() {
+		return _carrotContext?.permissions ?? [];
+	},
+	get grantedPermissions() {
+		return _carrotContext?.grantedPermissions ?? {};
+	},
+	get currentDir() {
+		return _carrotContext?.currentDir ?? "";
+	},
+	get statePath() {
+		return _carrotContext?.statePath ?? "";
+	},
+	get logsPath() {
+		return _carrotContext?.logsPath ?? "";
+	},
+	get authToken() {
+		return _carrotContext?.authToken ?? null;
+	},
+	async fetchAuthToken(): Promise<string | null> {
+		if (!bridge) return null;
+		const result = await bridge.requestHost<{ token: string | null }>("get-auth-token");
+		if (result?.token && _carrotContext) {
+			_carrotContext.authToken = result.token;
+		}
+		return result?.token ?? null;
+	},
+	async setAuthToken(token: string): Promise<void> {
+		if (!bridge) return;
+		await bridge.requestHost("set-auth-token", { token });
+		if (_carrotContext) {
+			_carrotContext.authToken = token;
+		}
+	},
+	get channel() {
+		return _carrotContext?.channel ?? "";
+	},
+	openManager() {
+		if (bridge) bridge.sendAction("open-manager");
+	},
+	openBunnyWindow(payload?: { screenX?: number; screenY?: number }) {
+		if (bridge) bridge.sendAction("open-bunny-window", payload);
+	},
+	async getWindowFrame(windowId?: string) {
+		if (!bridge) return null;
+		return bridge.requestHost<{ x: number; y: number; width: number; height: number } | null>("window-get-frame", { windowId });
+	},
+};
 
 // Named Exports
 export {

package/dist/api/bun/preload/build.ts

@@ -17,7 +17,7 @@ async function buildPreload() {
 	const fullResult = await Bun.build({
 		entrypoints: [fullPreloadEntry],
 		target: "browser",
-		format: "iife", // IIFE format for script injection (no export statements)
+		format: "esm",
 		minify: false,
 	});
 
@@ -31,7 +31,7 @@ async function buildPreload() {
 	const sandboxedResult = await Bun.build({
 		entrypoints: [sandboxedPreloadEntry],
 		target: "browser",
-		format: "iife",
+		format: "esm",
 		minify: false,
 	});
 
@@ -40,8 +40,10 @@ async function buildPreload() {
 		throw new Error("Failed to build sandboxed preload script");
 	}
 
-	const fullPreloadJs = await fullResult.outputs[0]!.text();
-	const sandboxedPreloadJs = await sandboxedResult.outputs[0]!.text();
+	// Bun does not currently support iife output, so we wrap the ESM bundle manually
+	// to keep preload globals scoped for script injection.
+	const fullPreloadJs = `(function(){${await fullResult.outputs[0]!.text()}})();`;
+	const sandboxedPreloadJs = `(function(){${await sandboxedResult.outputs[0]!.text()}})();`;
 
 	const outputContent = `// Auto-generated file. Do not edit directly.
 // Run "bun build.ts" or "bun build:dev" from the package folder to regenerate.