bunite-core 0.0.1 → 0.0.4

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "type": "module",
   "scripts": {
+    "setup:cef": "bun ../tools/bunite-dev/scripts/setup-cef.ts",
     "build:native:win": "cmake -S . -B build/win -DBUNITE_TARGET_ARCH=x64 && cmake --build build/win --config Release",
     "build:preload": "bun build src/preload/runtime.ts --outfile src/preload/runtime.built.js --target browser --minify"
   },
@@ -11,7 +12,7 @@
     ".": "./src/bun/index.ts",
     "./bun": "./src/bun/index.ts",
     "./view": "./src/view/index.ts",
-    "./config": "./src/types/config.ts",
+    "./webview-polyfill": "./src/shared/webviewPolyfill.ts",
     "./shared/rpc": "./src/shared/rpc.ts",
     "./package.json": "./package.json"
   },

package/src/bun/core/App.ts

@@ -1,18 +1,32 @@
-import { join } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { getBaseDir } from "../../shared/paths";
+import { dlopen, FFIType } from "bun:ffi";
 import { BuniteEvent } from "../events/event";
 import { buniteEventEmitter } from "../events/eventEmitter";
+import { handleMessageBoxResponse } from "./Utils";
 import {
   getNativeLibrary,
   initNativeRuntime,
   getNativeRuntimeState,
   setRouteRequestHandler,
+  setNativeLogLevel,
   toCString,
   type NativeBootstrapOptions
 } from "../proc/native";
 import { attachGlobalIPCResolver, ensureRPCServer } from "./Socket";
+import { BrowserWindow } from "./BrowserWindow";
+import { getSurfaceIPCHandlers } from "./SurfaceManager";
+import { getWebviewIPCHandlers } from "./SurfaceBrowserIPC";
+import { log, logLevelToInt } from "../../shared/log";
+
+import type { LogLevel } from "../../shared/log";
 
 type AppInitOptions = NativeBootstrapOptions & {
   userDataDir?: string;
+  cefDir?: string;
+  exitOnLastWindowClosed?: boolean;
+  logLevel?: LogLevel;
 };
 
 export type GlobalIPCHandler = (params: unknown, ctx: { viewId: number }) => unknown | Promise<unknown>;
@@ -21,14 +35,50 @@ class AppRuntime {
   private initPromise: Promise<void> | null = null;
   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;
+        }
+
+        if (options.logLevel) {
+          log.setLevel(options.logLevel);
+        }
+
+        if (options.cefDir) {
+          process.env.BUNITE_CEF_DIR = options.cefDir;
+        }
+
         if (options.userDataDir) {
           process.env.BUNITE_USER_DATA_DIR = options.userDataDir;
         } else if (!process.env.BUNITE_USER_DATA_DIR) {
-          process.env.BUNITE_USER_DATA_DIR = join(process.cwd(), ".bunite");
+          // 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);
         }
 
         const runtime = await initNativeRuntime({
@@ -38,12 +88,48 @@ class AppRuntime {
           chromiumFlags: options.chromiumFlags
         });
 
+        if (options.logLevel && runtime.nativeLoaded) {
+          setNativeLogLevel(logLevelToInt(options.logLevel));
+        }
+
         attachGlobalIPCResolver((channel) => this.getGlobalIPCHandler(channel));
+
+        for (const [channel, handler] of getSurfaceIPCHandlers()) {
+          this.globalIPCHandlers.set(channel, handler);
+        }
+        for (const [channel, handler] of getWebviewIPCHandlers()) {
+          this.globalIPCHandlers.set(channel, handler);
+        }
+
+        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));
 
-        // Replay view routes registered before init
-        for (const path of this.viewHandlers.keys()) {
-          getNativeLibrary()?.symbols.bunite_register_view_route(toCString(path));
+        // Replay appres routes registered before init
+        for (const path of this.appresHandlers.keys()) {
+          getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(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();
+              }
+            });
+          });
         }
 
         ensureRPCServer();
@@ -60,6 +146,11 @@ class AppRuntime {
   }
 
   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);
+    }
     const wrapped = (event: { data: unknown }) => handler(event.data);
     buniteEventEmitter.on(name, wrapped);
     return () => buniteEventEmitter.off(name, wrapped);
@@ -76,18 +167,31 @@ class AppRuntime {
     }
 
     if (!this.stubKeepAliveTimer) {
-      console.warn("[bunite] Running without a native event loop. Keeping the process alive in stub mode.");
+      log.warn("Running without a native event loop. Keeping the process alive in stub mode.");
       this.stubKeepAliveTimer = setInterval(() => {}, 60_000);
     }
   }
 
   quit(code = 0) {
+    if (this.quitting) {
+      return;
+    }
+    this.quitting = true;
+
+    const event = buniteEventEmitter.events.app.beforeQuit({});
+    buniteEventEmitter.emitEvent(event);
+    if (event.responseWasSet && event.response?.allow === false) {
+      this.quitting = false;
+      return;
+    }
     if (this.stubKeepAliveTimer) {
       clearInterval(this.stubKeepAliveTimer);
       this.stubKeepAliveTimer = null;
     }
+    // bunite_quit() blocks until native shutdown completes or times out
     getNativeLibrary()?.symbols.bunite_quit();
-    setTimeout(() => process.exit(code), 0);
+    process.exitCode = code;
+    process.exit(code);
   }
 
   handle(channel: string, handler: GlobalIPCHandler) {
@@ -110,23 +214,23 @@ class AppRuntime {
     return this.globalIPCHandlers.get(channel);
   }
 
-  private readonly viewHandlers = new Map<string, () => string>();
+  private readonly appresHandlers = new Map<string, () => string>();
 
-  getView(path: string, handler: () => string) {
-    this.viewHandlers.set(path, handler);
-    getNativeLibrary()?.symbols.bunite_register_view_route(toCString(path));
+  getAppRes(path: string, handler: () => string) {
+    this.appresHandlers.set(path, handler);
+    getNativeLibrary()?.symbols.bunite_register_appres_route(toCString(path));
   }
 
-  removeView(path: string) {
-    this.viewHandlers.delete(path);
-    getNativeLibrary()?.symbols.bunite_unregister_view_route(toCString(path));
+  removeAppRes(path: string) {
+    this.appresHandlers.delete(path);
+    getNativeLibrary()?.symbols.bunite_unregister_appres_route(toCString(path));
   }
 
   /** @internal */
   handleRouteRequest(requestId: number, path: string) {
     let html: string;
     try {
-      const handler = this.viewHandlers.get(path);
+      const handler = this.appresHandlers.get(path);
       html = handler ? handler() : "<html><body>No handler for: " + path + "</body></html>";
     } catch (error) {
       html = "<html><body>Route handler error: " + (error instanceof Error ? error.message : String(error)) + "</body></html>";
@@ -134,9 +238,45 @@ 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);
+  }
+
   get runtime() {
     return getNativeRuntimeState();
   }
+
+  get version(): string {
+    try {
+      const { createRequire } = require("node:module");
+      const req = createRequire(import.meta.url);
+      const pkg = req("bunite-core/package.json");
+      return pkg.version ?? "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+
+  private cachedCefVersion: string | null | undefined;
+
+  get cefVersion(): string | null {
+    if (this.cachedCefVersion !== undefined) return this.cachedCefVersion;
+    this.cachedCefVersion = null;
+    const arts = getNativeRuntimeState()?.artifacts;
+    if (!arts?.cefDir) return null;
+    const libcefPath = join(arts.cefDir, "libcef.dll");
+    if (!existsSync(libcefPath)) return null;
+    try {
+      const lib = dlopen(libcefPath, {
+        cef_version_info: { returns: FFIType.i32, args: [FFIType.i32] },
+      });
+      const v = (entry: number) => lib.symbols.cef_version_info(entry);
+      this.cachedCefVersion = `${v(0)}.${v(1)}.${v(2)}+chromium-${v(4)}.${v(5)}.${v(6)}.${v(7)}`;
+    } catch { /* leave as null */ }
+    return this.cachedCefVersion;
+  }
 }
 
 export const app = new AppRuntime();

package/src/bun/core/BrowserView.ts

@@ -1,11 +1,14 @@
+import { ptr } from "bun:ffi";
 import { buildViewPreloadScript } from "../preload/inline";
-import type { Pointer } from "bun:ffi";
+import { log } from "../../shared/log";
 import { buniteEventEmitter } from "../events/eventEmitter";
 import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport } from "../../shared/rpc";
-import { ensureNativeRuntime, getNativeLibrary, toCString } from "../proc/native";
+import { ensureNativeRuntime, getNativeLibrary, toCString, waitForViewReady, cancelWaitForViewReady } from "../proc/native";
 import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
 import { randomBytes } from "node:crypto";
-import { resolveDefaultViewsRoot } from "../../shared/paths";
+import { resolveDefaultAppResRoot } from "../../shared/paths";
+import { removeSurfacesForHostView } from "./SurfaceRegistry";
+import { cancelPendingMessageBoxesForView } from "./Utils";
 
 const BrowserViewMap: Record<number, BrowserView<any>> = {};
 let nextWebviewId = 1;
@@ -14,9 +17,9 @@ export type BrowserViewOptions<T = undefined> = {
   url: string | null;
   html: string | null;
   preload: string | null;
-  viewsRoot: string | null;
+  appresRoot: string | null;
+  preloadOrigins?: string[];
   partition: string | null;
-  windowPtr?: Pointer | null;
   frame: {
     x: number;
     y: number;
@@ -34,9 +37,9 @@ const defaultOptions: BrowserViewOptions = {
   url: null,
   html: null,
   preload: null,
-  viewsRoot: null,
+  appresRoot: null,
+  preloadOrigins: undefined,
   partition: null,
-  windowPtr: null,
   frame: {
     x: 0,
     y: 0,
@@ -51,12 +54,14 @@ const defaultOptions: BrowserViewOptions = {
 
 export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
   id = nextWebviewId++;
-  ptr: Pointer | null = null;
+  private nativeAttached = false;
+  private _readyPromise: Promise<void>;
   windowId: number;
   url: string | null;
   html: string | null;
   preload: string | null;
-  viewsRoot: string | null;
+  appresRoot: string | null;
+  preloadOrigins?: string[];
   partition: string | null;
   frame: BrowserViewOptions["frame"];
   rpc?: T;
@@ -73,7 +78,8 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
     this.url = options.url ?? defaultOptions.url;
     this.html = options.html ?? defaultOptions.html;
     this.preload = options.preload ?? defaultOptions.preload;
-    this.viewsRoot = options.viewsRoot ?? defaultOptions.viewsRoot ?? resolveDefaultViewsRoot();
+    this.appresRoot = options.appresRoot ?? defaultOptions.appresRoot ?? resolveDefaultAppResRoot();
+    this.preloadOrigins = options.preloadOrigins ?? defaultOptions.preloadOrigins;
     this.partition = options.partition ?? defaultOptions.partition;
     this.frame = options.frame ?? defaultOptions.frame;
     this.rpc = options.rpc;
@@ -86,12 +92,12 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
       throw new Error("sandboxed BrowserView is not implemented in Bunite Windows Phase 1 yet.");
     }
     if (this.partition) {
-      console.warn("[bunite] BrowserView.partition is not implemented in Bunite Windows Phase 1 yet.");
+      log.warn("BrowserView.partition is not implemented in Bunite Windows Phase 1 yet.");
     }
 
     const preloadScript = buildViewPreloadScript({
       preload: this.preload,
-      viewsRoot: this.viewsRoot,
+      appresRoot: this.appresRoot,
       webviewId: this.id,
       rpcSocketPort: getRPCPort(),
       secretKey: this.secretKey
@@ -99,22 +105,51 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 
     BrowserViewMap[this.id] = this;
     this.rpc?.setTransport(this.createTransport());
-    this.ptr =
+    // Register ready waiter BEFORE native create — OnAfterCreated can fire
+    // on the CEF UI thread before bunite_view_create returns to JS.
+    this._readyPromise = waitForViewReady(this.id);
+    this.nativeAttached =
       getNativeLibrary()?.symbols.bunite_view_create(
         this.id,
-        options.windowPtr ?? null,
+        this.windowId,
         toCString(this.url ?? ""),
         toCString(this.html ?? ""),
         toCString(preloadScript),
-        toCString(this.viewsRoot ?? ""),
+        toCString(this.appresRoot ?? ""),
         toCString(this.navigationRules ? JSON.stringify(this.navigationRules) : ""),
         this.frame.x,
         this.frame.y,
         this.frame.width,
         this.frame.height,
         this.autoResize,
-        this.sandbox
-      ) ?? null;
+        this.sandbox,
+        toCString(this.preloadOrigins ? JSON.stringify(this.preloadOrigins) : "")
+      ) ?? false;
+
+    if (this.nativeAttached) {
+      // Clean up owned surfaces when this view navigates (page refresh/navigation
+      // destroys the JS context without firing disconnectedCallback).
+      // Uses did-navigate (not will-navigate) because will-navigate fires even
+      // when navigation is denied by navigationRules.
+      this.on("did-navigate", (event: any) => {
+        this.url = event.data?.detail ?? this.url;
+        cancelPendingMessageBoxesForView(this.id);
+        removeSurfacesForHostView(this.id);
+      });
+    } else {
+      cancelWaitForViewReady(this.id);
+      this._readyPromise = Promise.reject(new Error("Native view creation failed"));
+      this._readyPromise.catch(() => {}); // prevent unhandled rejection
+    }
+  }
+
+  whenReady(timeoutMs = 8000): Promise<void> {
+    return Promise.race([
+      this._readyPromise,
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error(`Browser creation timed out for view ${this.id}`)), timeoutMs)
+      )
+    ]);
   }
 
   static getById(id: number) {
@@ -155,84 +190,130 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 
   setAnchor(mode: "none" | "fill" | "top" | "below-top", inset = 0) {
     const modeInt = { none: 0, fill: 1, top: 2, "below-top": 3 }[mode];
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_set_anchor(this.ptr, modeInt, inset);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_set_anchor(this.id, modeInt, inset);
+    }
+  }
+
+  executeJavaScript(script: string) {
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_execute_javascript(this.id, toCString(script));
     }
   }
 
   goBack() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_go_back(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_go_back(this.id);
     }
   }
 
   reload() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_reload(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_reload(this.id);
     }
   }
 
   setVisible(visible: boolean) {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_set_visible(this.ptr, visible);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_set_visible(this.id, visible);
+    }
+  }
+
+  setInputPassthrough(passthrough: boolean) {
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_set_input_passthrough(this.id, passthrough);
+    }
+  }
+
+  setMaskRegion(rects: Array<{ x: number; y: number; w: number; h: number }>) {
+    if (!this.nativeAttached) return;
+    if (rects.length === 0) {
+      getNativeLibrary()?.symbols.bunite_view_set_mask_region(this.id, null as any, 0);
+      return;
+    }
+    const buf = new Float64Array(rects.length * 4);
+    for (let i = 0; i < rects.length; i++) {
+      buf[i * 4] = rects[i].x;
+      buf[i * 4 + 1] = rects[i].y;
+      buf[i * 4 + 2] = rects[i].w;
+      buf[i * 4 + 3] = rects[i].h;
+    }
+    getNativeLibrary()?.symbols.bunite_view_set_mask_region(
+      this.id, ptr(buf.buffer), rects.length
+    );
+  }
+
+  bringToFront() {
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_bring_to_front(this.id);
     }
   }
 
   setBounds(x: number, y: number, width: number, height: number) {
     this.frame = { x, y, width, height };
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_set_bounds(this.ptr, x, y, width, height);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_set_bounds(this.id, x, y, width, height);
+    }
+  }
+
+  /** Fire-and-forget setBounds — does not block on the UI thread. */
+  setBoundsAsync(x: number, y: number, width: number, height: number) {
+    this.frame = { x, y, width, height };
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_set_bounds_async(this.id, x, y, width, height);
     }
   }
 
   loadURL(url: string) {
     this.url = url;
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_load_url(this.ptr, toCString(url));
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_load_url(this.id, toCString(url));
     }
   }
 
   loadHTML(html: string) {
     this.html = html;
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_load_html(this.ptr, toCString(html));
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_load_html(this.id, toCString(html));
     }
   }
 
   remove() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_remove(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_remove(this.id);
     }
     this.detachFromNative();
   }
 
   openDevTools() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_open_devtools(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_open_devtools(this.id);
     }
   }
 
   closeDevTools() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_close_devtools(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_close_devtools(this.id);
     }
   }
 
   toggleDevTools() {
-    if (this.ptr) {
-      getNativeLibrary()?.symbols.bunite_view_toggle_devtools(this.ptr);
+    if (this.nativeAttached) {
+      getNativeLibrary()?.symbols.bunite_view_toggle_devtools(this.id);
     }
   }
 
   detachFromNative() {
-    this.ptr = null;
+    cancelPendingMessageBoxesForView(this.id);
+    removeSurfacesForHostView(this.id);
+    cancelWaitForViewReady(this.id);
+    this.nativeAttached = false;
     for (const eventName of [
       "will-navigate",
       "did-navigate",
       "dom-ready",
       "new-window-open",
-      "permission-requested",
-      "message-box-response"
+      "permission-requested"
     ]) {
       buniteEventEmitter.removeAllListeners(`${eventName}-${this.id}`);
     }
@@ -245,8 +326,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
       | "did-navigate"
       | "dom-ready"
       | "new-window-open"
-      | "permission-requested"
-      | "message-box-response",
+      | "permission-requested",
     handler: (event: unknown) => void
   ) {
     const specificName = `${name}-${this.id}`;