bunite-core 0.0.4 → 0.0.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "scripts": {
     "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",

package/src/bun/core/App.ts

@@ -22,7 +22,7 @@ import { log, logLevelToInt } from "../../shared/log";
 
 import type { LogLevel } from "../../shared/log";
 
-type AppInitOptions = NativeBootstrapOptions & {
+type AppOptions = NativeBootstrapOptions & {
   userDataDir?: string;
   cefDir?: string;
   exitOnLastWindowClosed?: boolean;
@@ -31,123 +31,116 @@ type AppInitOptions = NativeBootstrapOptions & {
 
 export type GlobalIPCHandler = (params: unknown, ctx: { viewId: number }) => unknown | Promise<unknown>;
 
-class AppRuntime {
-  private initPromise: Promise<void> | null = null;
+export class AppRuntime {
   private stubKeepAliveTimer: ReturnType<typeof setInterval> | null = null;
   private readonly globalIPCHandlers = new Map<string, GlobalIPCHandler>();
   private exitOnLastWindowClosed = true;
   private quitting = false;
 
-  async init(options: AppInitOptions = {}) {
-    if (!this.initPromise) {
-      this.initPromise = (async () => {
-        if (options.exitOnLastWindowClosed !== undefined) {
-          this.exitOnLastWindowClosed = options.exitOnLastWindowClosed;
-        }
+  readonly ready: Promise<void>;
 
-        if (options.logLevel) {
-          log.setLevel(options.logLevel);
-        }
+  constructor(options: AppOptions = {}) {
+    this.ready = this.bootstrap(options);
+  }
 
-        if (options.cefDir) {
-          process.env.BUNITE_CEF_DIR = options.cefDir;
-        }
+  private async bootstrap(options: AppOptions) {
+    if (options.exitOnLastWindowClosed !== undefined) {
+      this.exitOnLastWindowClosed = options.exitOnLastWindowClosed;
+    }
 
-        if (options.userDataDir) {
-          process.env.BUNITE_USER_DATA_DIR = options.userDataDir;
-        } else if (!process.env.BUNITE_USER_DATA_DIR) {
-          // XDG_DATA_HOME takes priority on any platform, then OS convention
-          const appDataDir = process.env.XDG_DATA_HOME
-            ?? (process.platform === "win32"
-              ? (process.env.APPDATA ?? join(process.env.USERPROFILE ?? "", "AppData", "Roaming"))
-              : process.platform === "darwin"
-                ? join(process.env.HOME ?? "", "Library", "Application Support")
-                : join(process.env.HOME ?? "", ".local", "share"));
-          let name = "bunite-app";
-          try {
-            // Walk up from entry script to find nearest package.json
-            let dir = getBaseDir();
-            while (dir) {
-              const pkgPath = join(dir, "package.json");
-              if (existsSync(pkgPath)) {
-                name = JSON.parse(require("node:fs").readFileSync(pkgPath, "utf8")).name ?? name;
-                break;
-              }
-              const parent = resolve(dir, "..");
-              if (parent === dir) break;
-              dir = parent;
-            }
-          } catch {}
-          process.env.BUNITE_USER_DATA_DIR = join(appDataDir, name);
-        }
+    if (options.logLevel) {
+      log.setLevel(options.logLevel);
+    }
 
-        const runtime = await initNativeRuntime({
-          allowStub: options.allowStub,
-          hideConsole: options.hideConsole,
-          popupBlocking: options.popupBlocking,
-          chromiumFlags: options.chromiumFlags
-        });
+    if (options.cefDir) {
+      process.env.BUNITE_CEF_DIR = options.cefDir;
+    }
 
-        if (options.logLevel && runtime.nativeLoaded) {
-          setNativeLogLevel(logLevelToInt(options.logLevel));
+    if (options.userDataDir) {
+      process.env.BUNITE_USER_DATA_DIR = options.userDataDir;
+    } else if (!process.env.BUNITE_USER_DATA_DIR) {
+      const appDataDir = process.env.XDG_DATA_HOME
+        ?? (process.platform === "win32"
+          ? (process.env.APPDATA ?? join(process.env.USERPROFILE ?? "", "AppData", "Roaming"))
+          : process.platform === "darwin"
+            ? join(process.env.HOME ?? "", "Library", "Application Support")
+            : join(process.env.HOME ?? "", ".local", "share"));
+      let name = "bunite-app";
+      try {
+        let dir = getBaseDir();
+        while (dir) {
+          const pkgPath = join(dir, "package.json");
+          if (existsSync(pkgPath)) {
+            name = JSON.parse(require("node:fs").readFileSync(pkgPath, "utf8")).name ?? name;
+            break;
+          }
+          const parent = resolve(dir, "..");
+          if (parent === dir) break;
+          dir = parent;
         }
+      } catch {}
+      process.env.BUNITE_USER_DATA_DIR = join(appDataDir, name);
+    }
 
-        attachGlobalIPCResolver((channel) => this.getGlobalIPCHandler(channel));
+    const runtime = await initNativeRuntime({
+      allowStub: options.allowStub,
+      hideConsole: options.hideConsole,
+      popupBlocking: options.popupBlocking,
+      chromiumFlags: options.chromiumFlags
+    });
 
-        for (const [channel, handler] of getSurfaceIPCHandlers()) {
-          this.globalIPCHandlers.set(channel, handler);
-        }
-        for (const [channel, handler] of getWebviewIPCHandlers()) {
-          this.globalIPCHandlers.set(channel, handler);
-        }
+    if (options.logLevel && runtime.nativeLoaded) {
+      setNativeLogLevel(logLevelToInt(options.logLevel));
+    }
 
-        this.globalIPCHandlers.set("__bunite:messageBoxResponse", (params) => {
-          const { requestId, response } = params as { requestId: number; response: number };
-          handleMessageBoxResponse(requestId, response);
-          return {};
-        });
+    attachGlobalIPCResolver((channel) => this.getGlobalIPCHandler(channel));
 
-        setRouteRequestHandler((requestId, path) => this.handleRouteRequest(requestId, path));
+    for (const [channel, handler] of getSurfaceIPCHandlers()) {
+      this.globalIPCHandlers.set(channel, handler);
+    }
+    for (const [channel, handler] of getWebviewIPCHandlers()) {
+      this.globalIPCHandlers.set(channel, handler);
+    }
 
-        // Replay appres routes registered before init
-        for (const path of this.appresHandlers.keys()) {
-          getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(path));
-        }
+    this.globalIPCHandlers.set("__bunite:messageBoxResponse", (params) => {
+      const { requestId, response } = params as { requestId: number; response: number };
+      handleMessageBoxResponse(requestId, response);
+      return {};
+    });
 
+    setRouteRequestHandler((requestId, path) => this.handleRouteRequest(requestId, path));
 
-        if (this.exitOnLastWindowClosed && runtime.nativeLoaded) {
-          buniteEventEmitter.on("all-windows-closed", () => {
-            if (this.quitting) {
-              return;
-            }
-            queueMicrotask(() => {
-              if (this.quitting) {
-                return;
-              }
-              // Recheck: a new window may have been created since the event
-              if (BrowserWindow.getAll().length === 0) {
-                this.quit();
-              }
-            });
-          });
-        }
+    for (const path of this.appresHandlers.keys()) {
+      getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(path));
+    }
 
-        ensureRPCServer();
-        buniteEventEmitter.emitEvent(
-          new BuniteEvent("ready", {
-            usingStub: runtime.usingStub,
-            artifacts: runtime.artifacts
-          })
-        );
-      })();
+    if (this.exitOnLastWindowClosed && runtime.nativeLoaded) {
+      buniteEventEmitter.on("all-windows-closed", () => {
+        if (this.quitting) {
+          return;
+        }
+        queueMicrotask(() => {
+          if (this.quitting) {
+            return;
+          }
+          if (BrowserWindow.getAll().length === 0) {
+            this.quit();
+          }
+        });
+      });
     }
 
-    await this.initPromise;
+    ensureRPCServer();
+    buniteEventEmitter.emitEvent(
+      new BuniteEvent("ready", {
+        usingStub: runtime.usingStub,
+        artifacts: runtime.artifacts
+      })
+    );
   }
 
   on(name: string, handler: (payload: unknown) => void) {
     if (name === "before-quit") {
-      // before-quit listeners receive the BuniteEvent directly so they can set event.response
       buniteEventEmitter.on(name, handler);
       return () => buniteEventEmitter.off(name, handler);
     }
@@ -188,7 +181,6 @@ class AppRuntime {
       clearInterval(this.stubKeepAliveTimer);
       this.stubKeepAliveTimer = null;
     }
-    // bunite_quit() blocks until native shutdown completes or times out
     getNativeLibrary()?.symbols.bunite_quit();
     process.exitCode = code;
     process.exit(code);
@@ -238,7 +230,6 @@ class AppRuntime {
     getNativeLibrary()?.symbols.bunite_complete_route_request(requestId, toCString(html));
   }
 
-  /** Resolve a path relative to the entry script (dev) or executable (compiled). */
   resolve(relativePath: string): string {
     if (isAbsolute(relativePath)) return relativePath;
     return resolve(getBaseDir(), relativePath);
@@ -278,5 +269,3 @@ class AppRuntime {
     return this.cachedCefVersion;
   }
 }
-
-export const app = new AppRuntime();

package/src/bun/core/BrowserView.ts

@@ -2,7 +2,8 @@ import { ptr } from "bun:ffi";
 import { buildViewPreloadScript } from "../preload/inline";
 import { log } from "../../shared/log";
 import { buniteEventEmitter } from "../events/eventEmitter";
-import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport } from "../../shared/rpc";
+import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport, type RPCRequestHandler } from "../../shared/rpc";
+import { createWebRPCHandler } from "../../shared/webRpcHandler";
 import { ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady } from "../proc/native";
 import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
 import { randomBytes } from "node:crypto";
@@ -163,7 +164,10 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
   static defineRPC<Schema extends BuniteRPCSchema>(
     config: BuniteRPCConfig<Schema, "bun">
   ) {
-    return defineBuniteRPC("bun", config);
+    const rpc = defineBuniteRPC("bun", config);
+    return Object.assign(rpc, {
+      webHandler: createWebRPCHandler((config.handlers.requests ?? {}) as any)
+    });
   }
 
   handleIncomingRPC(message: unknown) {

package/src/bun/index.ts

@@ -1,4 +1,4 @@
-import { app } from "./core/App";
+import { AppRuntime } from "./core/App";
 import { BrowserWindow, type WindowOptionsType } from "./core/BrowserWindow";
 import { BrowserView, type BrowserViewOptions } from "./core/BrowserView";
 import * as Utils from "./core/Utils";
@@ -17,7 +17,7 @@ import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
 import { log, type LogLevel } from "../shared/log";
 
 export {
-  app,
+  AppRuntime,
   BrowserWindow,
   BrowserView,
   Utils,

package/src/shared/webRpcHandler.ts

@@ -0,0 +1,48 @@
+import { decodeRPCPacket, encodeRPCPacket, asUint8Array } from "./rpcWire";
+
+type WebRPCHandlers = Record<string, (params?: unknown) => unknown>;
+
+/** Minimal ws interface compatible with Bun's ServerWebSocket. */
+type WebRPCSocket = { send(data: Uint8Array): void | number };
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function createWebRPCHandler(handlers: WebRPCHandlers) {
+  return {
+    message(ws: WebRPCSocket, raw: string | Buffer) {
+      if (typeof raw === "string") return;
+
+      let packet;
+      try {
+        packet = decodeRPCPacket(asUint8Array(raw));
+      } catch {
+        return;
+      }
+
+      if (packet.type !== "request" || typeof packet.method !== "string") return;
+
+      const handler = handlers[packet.method];
+      if (!handler) {
+        ws.send(
+          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: `Unknown method: ${packet.method}` })
+        );
+        return;
+      }
+
+      try {
+        Promise.resolve(handler(packet.params)).then(
+          (payload) =>
+            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: true, payload })),
+          (error) =>
+            ws.send(encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) }))
+        );
+      } catch (error) {
+        ws.send(
+          encodeRPCPacket({ type: "response", id: packet.id, success: false, error: errorMessage(error) })
+        );
+      }
+    }
+  };
+}

package/src/shared/webviewPolyfill.ts

@@ -1,11 +1,4 @@
-/**
- * <bunite-webview> iframe polyfill — registered automatically via the
- * bunite-dev vite plugin when the native bunite runtime is not available.
- *
- * In desktop CEF the native element is already registered by the preload
- * runtime, so this module does nothing.
- */
-
+// Iframe-based fallback for web browsers. No-op when the native element is already registered by the CEF preload.
 if (
   typeof customElements !== "undefined" &&
   !customElements.get("bunite-webview")

package/src/view/index.ts

@@ -1,3 +1,4 @@
+import "../shared/webviewPolyfill";
 import {
   defineBuniteRPC,
   type BuniteRPCConfig,
@@ -25,6 +26,8 @@ const buniteWindow = window as BuniteWindowGlobals;
 const WEBVIEW_ID = buniteWindow.__buniteWebviewId;
 const RPC_SOCKET_PORT = buniteWindow.__buniteRpcSocketPort;
 
+const isNative = WEBVIEW_ID != null && RPC_SOCKET_PORT != null;
+
 function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
   const copy = new Uint8Array(bytes.byteLength);
   copy.set(bytes);
@@ -35,6 +38,7 @@ export class BuniteView<T extends RPCWithTransport> {
   bunSocket?: WebSocket;
   rpc?: T;
   rpcHandler?: (message: unknown) => void;
+  private pendingPackets: RPCPacket[] = [];
 
   constructor(config: { rpc: T }) {
     this.rpc = config.rpc;
@@ -43,69 +47,96 @@ export class BuniteView<T extends RPCWithTransport> {
 
   init() {
     this.initSocketToBun();
-    buniteWindow.__bunite ??= {};
-    buniteWindow.__bunite.receiveMessageFromBun = this.receiveMessageFromBun.bind(this);
+    if (isNative) {
+      buniteWindow.__bunite ??= {};
+      buniteWindow.__bunite.receiveMessageFromBun = this.receiveMessageFromBun.bind(this);
+    }
     this.rpc?.setTransport(this.createTransport());
   }
 
-  initSocketToBun() {
-    if (WEBVIEW_ID == null || RPC_SOCKET_PORT == null) {
-      log.warn("Preload globals are missing. BuniteView will stay disconnected until native preload wiring is implemented.");
-      return;
+  private sendPacket(packet: RPCPacket) {
+    if (isNative) {
+      void this.bunBridge(packet).catch((error) => {
+        log.error("Failed to send RPC packet", error);
+      });
+    } else {
+      this.bunSocket!.send(toArrayBuffer(encodeRPCPacket(packet)));
     }
+  }
 
-    // Share a single WebSocket with the preload's bunite.invoke.
-    // Whichever side (BuniteView or bunite.invoke) opens the socket first,
-    // the other reuses it via __bunite._socket.
-    const globals = buniteWindow as any;
-    globals.__bunite ??= {};
-    const existing = globals.__bunite._socket;
-    if (existing && existing.readyState <= WebSocket.OPEN) {
-      this.bunSocket = existing;
-    } else {
-      const socket = new WebSocket(
-        `ws://localhost:${RPC_SOCKET_PORT}/socket?webviewId=${WEBVIEW_ID}`
-      );
+  initSocketToBun() {
+    if (!isNative) {
+      const proto = location.protocol === "https:" ? "wss:" : "ws:";
+      const socket = new WebSocket(`${proto}//${location.host}/rpc`);
       socket.binaryType = "arraybuffer";
       this.bunSocket = socket;
-      globals.__bunite._socket = socket;
-    }
 
-    this.bunSocket!.addEventListener("message", async (event) => {
-      const binaryMessage = await this.messageToUint8Array(event.data);
-      if (!binaryMessage) {
-        return;
+      socket.addEventListener("message", async (event) => {
+        const bytes = await this.messageToUint8Array(event.data);
+        if (!bytes) return;
+        try {
+          this.rpcHandler?.(decodeRPCPacket(bytes));
+        } catch (error) {
+          log.error("Failed to parse WebSocket message", error);
+        }
+      });
+    } else {
+      // Share a single WebSocket with the preload's bunite.invoke.
+      const globals = buniteWindow as any;
+      globals.__bunite ??= {};
+      const existing = globals.__bunite._socket;
+      if (existing && existing.readyState <= WebSocket.OPEN) {
+        this.bunSocket = existing;
+      } else {
+        const socket = new WebSocket(
+          `ws://localhost:${RPC_SOCKET_PORT}/socket?webviewId=${WEBVIEW_ID}`
+        );
+        socket.binaryType = "arraybuffer";
+        this.bunSocket = socket;
+        globals.__bunite._socket = socket;
       }
 
-      try {
-        const decrypt = buniteWindow.__bunite_decrypt;
-        if (!decrypt) {
-          log.error("No decrypt function available in preload globals");
-          return;
-        }
-        const decrypted = await decrypt(binaryMessage);
-        const packet = decodeRPCPacket(decrypted);
-        // Skip global IPC responses — those are handled by bunite.invoke in the preload
-        if ((packet as any).scope === "global") {
-          return;
+      this.bunSocket!.addEventListener("message", async (event) => {
+        const binaryMessage = await this.messageToUint8Array(event.data);
+        if (!binaryMessage) return;
+
+        try {
+          const decrypt = buniteWindow.__bunite_decrypt;
+          if (!decrypt) {
+            log.error("No decrypt function available in preload globals");
+            return;
+          }
+          const decrypted = await decrypt(binaryMessage);
+          const packet = decodeRPCPacket(decrypted);
+          if ((packet as any).scope === "global") return;
+          this.rpcHandler?.(packet);
+        } catch (error) {
+          log.error("Failed to parse message from Bun", error);
         }
-        this.rpcHandler?.(packet);
-      } catch (error) {
-        log.error("Failed to parse message from Bun", error);
+      });
+    }
+
+    this.bunSocket!.addEventListener("open", () => {
+      for (const packet of this.pendingPackets) this.sendPacket(packet);
+      this.pendingPackets = [];
+    });
+
+    this.bunSocket!.addEventListener("error", () => {
+      log.error("RPC WebSocket error");
+    });
+
+    this.bunSocket!.addEventListener("close", () => {
+      if (this.pendingPackets.length > 0) {
+        log.error(`RPC WebSocket closed with ${this.pendingPackets.length} pending packets`);
+        this.pendingPackets = [];
       }
     });
   }
 
   async messageToUint8Array(data: unknown) {
-    if (data instanceof ArrayBuffer) {
-      return new Uint8Array(data);
-    }
-    if (data instanceof Blob) {
-      return new Uint8Array(await data.arrayBuffer());
-    }
-    if (data instanceof Uint8Array) {
-      return data;
-    }
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+    if (data instanceof Uint8Array) return data;
     return null;
   }
 
@@ -113,9 +144,9 @@ export class BuniteView<T extends RPCWithTransport> {
     return {
       send: (message) => {
         if (this.bunSocket?.readyState === WebSocket.OPEN) {
-          void this.bunBridge(message).catch((error) => {
-            log.error("Failed to send RPC packet", error);
-          });
+          this.sendPacket(message);
+        } else if (this.bunSocket?.readyState === WebSocket.CONNECTING) {
+          this.pendingPackets.push(message);
         }
       },
       registerHandler: (handler: (packet: any) => void) => {
@@ -132,9 +163,7 @@ export class BuniteView<T extends RPCWithTransport> {
   }
 
   async bunBridge(message: RPCPacket) {
-    if (this.bunSocket?.readyState !== WebSocket.OPEN) {
-      return;
-    }
+    if (this.bunSocket?.readyState !== WebSocket.OPEN) return;
 
     const encrypt = buniteWindow.__bunite_encrypt;
     if (!encrypt) {
@@ -149,7 +178,9 @@ export class BuniteView<T extends RPCWithTransport> {
   static defineRPC<Schema extends BuniteRPCSchema>(
     config: BuniteRPCConfig<Schema, "webview">
   ) {
-    return defineBuniteRPC("webview", config);
+    const rpc = defineBuniteRPC("webview", config);
+    new BuniteView({ rpc });
+    return rpc;
   }
 }