bunite-core 0.6.0 → 0.8.1

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "bunite-core",
   "description": "Uniting UI and Bun",
-  "version": "0.6.0",
+  "version": "0.8.1",
   "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:native:linux": "cmake -S . -B build/linux -DCMAKE_BUILD_TYPE=Release && cmake --build build/linux",
     "build:preload": "bun build src/preload/runtime.ts --outfile src/preload/runtime.built.js --target browser --minify"
   },
   "exports": {
@@ -22,6 +23,8 @@
     "msgpackr": "^1.11.9"
   },
   "optionalDependencies": {
-    "bunite-native-win-x64": "0.0.3"
+    "bunite-native-win-x64": "0.0.4",
+    "bunite-native-mac-arm64": "0.0.1",
+    "bunite-native-linux-x64": "0.0.1"
   }
 }

package/src/bun/core/App.ts

@@ -1,11 +1,11 @@
 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 {
+  getNativeEngineName,
+  getNativeEngineVersion,
   getNativeLibrary,
   initNativeRuntime,
   getNativeRuntimeState,
@@ -24,7 +24,6 @@ import type { LogLevel } from "../../shared/log";
 
 type AppOptions = NativeBootstrapOptions & {
   userDataDir?: string;
-  cefDir?: string;
   exitOnLastWindowClosed?: boolean;
   logLevel?: LogLevel;
 };
@@ -40,6 +39,7 @@ export class AppRuntime {
   private readonly globalIPCHandlers = new Map<string, GlobalIPCHandler>();
   private exitOnLastWindowClosed = true;
   private quitting = false;
+  private pumpActive = false;
 
   readonly ready: Promise<void>;
 
@@ -56,10 +56,6 @@ export class AppRuntime {
       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) {
@@ -90,7 +86,7 @@ export class AppRuntime {
       allowStub: options.allowStub,
       hideConsole: options.hideConsole,
       popupBlocking: options.popupBlocking,
-      chromiumFlags: options.chromiumFlags
+      engineFlags: options.engineFlags
     });
 
     if (options.logLevel && runtime.nativeLoaded) {
@@ -106,12 +102,6 @@ export class AppRuntime {
       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));
 
     for (const path of this.appresHandlers.keys()) {
@@ -155,16 +145,28 @@ export class AppRuntime {
 
   run() {
     const runtime = getNativeRuntimeState();
-    if (runtime?.nativeLoaded) {
-      getNativeLibrary()?.symbols.bunite_run_loop();
+    if (!runtime?.nativeLoaded) {
       if (!this.stubKeepAliveTimer) {
+        log.warn("Running without a native event loop. Keeping the process alive in stub mode.");
         this.stubKeepAliveTimer = setInterval(() => {}, 60_000);
       }
       return;
     }
 
-    if (!this.stubKeepAliveTimer) {
-      log.warn("Running without a native event loop. Keeping the process alive in stub mode.");
+    const lib = getNativeLibrary();
+    lib?.symbols.bunite_run_loop();
+
+    if (process.platform === "darwin" || process.platform === "linux") {
+      // AppKit / WebKitGTK share Bun's main thread — step-drive via setImmediate (no blocking loop).
+      this.pumpActive = true;
+      const pump = () => {
+        if (!this.pumpActive) return;
+        lib?.symbols.bunite_pump_once();
+        setImmediate(pump);
+      };
+      pump();
+    } else if (!this.stubKeepAliveTimer) {
+      // Engines with a dedicated UI thread (Windows CEF) only need Bun's loop kept alive.
       this.stubKeepAliveTimer = setInterval(() => {}, 60_000);
     }
   }
@@ -181,6 +183,7 @@ export class AppRuntime {
       this.quitting = false;
       return;
     }
+    this.pumpActive = false;
     if (this.stubKeepAliveTimer) {
       clearInterval(this.stubKeepAliveTimer);
       this.stubKeepAliveTimer = null;
@@ -256,22 +259,20 @@ export class AppRuntime {
     }
   }
 
-  private cachedCefVersion: string | null | undefined;
+  private cachedEngineName: string | null | undefined;
+  private cachedEngineVersion: 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;
+  /** Active engine identifier reported by the native adapter (e.g. `"cef"`, `"wkwebview"`, `"webkitgtk"`). */
+  get engineName(): string | null {
+    if (this.cachedEngineName !== undefined) return this.cachedEngineName;
+    this.cachedEngineName = getNativeEngineName();
+    return this.cachedEngineName;
+  }
+
+  /** Engine version string reported by the native adapter. Format depends on engine. */
+  get engineVersion(): string | null {
+    if (this.cachedEngineVersion !== undefined) return this.cachedEngineVersion;
+    this.cachedEngineVersion = getNativeEngineVersion();
+    return this.cachedEngineVersion;
   }
 }

package/src/bun/core/BrowserView.ts

@@ -8,7 +8,6 @@ import { attachBrowserViewRegistry, getRpcPort, sendMessageToView } from "./Sock
 import { randomBytes } from "node:crypto";
 import { resolveDefaultAppResRoot } from "../../shared/paths";
 import { removeSurfacesForHostView } from "./SurfaceRegistry";
-import { cancelPendingMessageBoxesForView } from "./Utils";
 
 const BrowserViewMap: Record<number, BrowserView<any>> = {};
 let nextWebviewId = 1;
@@ -119,8 +118,7 @@ export class BrowserView<T extends RpcWithTransport = RpcWithTransport> {
 
     BrowserViewMap[this.id] = this;
     this.rpc?.setTransport(this.transport);
-    // Register ready waiter BEFORE native create — OnAfterCreated can fire
-    // on the CEF UI thread before bunite_view_create returns to JS.
+    // Register before native create — view-ready can fire on the UI thread before bunite_view_create returns.
     this._readyPromise = waitForViewReady(this.id);
     this.nativeAttached =
       getNativeLibrary()?.symbols.bunite_view_create(
@@ -141,13 +139,10 @@ export class BrowserView<T extends RpcWithTransport = RpcWithTransport> {
       ) ?? 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.
+      // did-navigate (not will-): nav destroys JS context without disconnectedCallback;
+      // will-navigate fires even when rules deny → would leak surfaces.
       this.on("did-navigate", (event: any) => {
         this.url = event.data?.detail ?? this.url;
-        cancelPendingMessageBoxesForView(this.id);
         removeSurfacesForHostView(this.id);
       });
     } else {
@@ -298,7 +293,6 @@ export class BrowserView<T extends RpcWithTransport = RpcWithTransport> {
   }
 
   detachFromNative() {
-    cancelPendingMessageBoxesForView(this.id);
     removeSurfacesForHostView(this.id);
     cancelWaitForViewReady(this.id);
     this.nativeAttached = false;

package/src/bun/core/singleInstanceLock.ts

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import { closeSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export type SingleInstanceLock =
+  | { acquired: true; release(): void }
+  | { acquired: false; holderPid?: number };
+
+export function lockPathFor(key: string): string {
+  const slug = createHash("sha1").update(key).digest("hex").slice(0, 16);
+  return join(tmpdir(), `bunite-instance-${slug}.lock`);
+}
+
+function isProcessAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const code = (e as NodeJS.ErrnoException).code;
+    // EPERM means the process exists but is owned by someone else.
+    return code === "EPERM";
+  }
+}
+
+function readHolderPid(path: string): number | undefined {
+  try {
+    const pid = parseInt(readFileSync(path, "utf8").trim(), 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Acquire a process-wide single-instance lock keyed by `key`. Returns a release
+ * handle on success, or the current holder's PID on contention. Dead-PID locks
+ * are reclaimed automatically; in-flight contention (lockfile present but PID
+ * not yet written / unreadable) is surfaced as `acquired: false` without a PID
+ * rather than racing to unlink the contender's lockfile.
+ *
+ * Use BEFORE app.init() — second instance can prompt UX and exit instead of
+ * crashing on engine-specific userDataDir locks.
+ *
+ * Caveats: `process.on("exit")` cleanup does not run on SIGKILL or crash; the
+ * next instance reclaims via PID-liveness probe. PID reuse can mask a dead
+ * original holder until the unrelated process exits.
+ */
+export function acquireSingleInstanceLock(key: string): SingleInstanceLock {
+  const path = lockPathFor(key);
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(path, "wx");
+      writeFileSync(fd, String(process.pid));
+      closeSync(fd);
+      let released = false;
+      const release = () => {
+        if (released) return;
+        released = true;
+        // Verify ownership before unlinking — guards against deleting a lockfile
+        // that has been reclaimed by another process if our exit was delayed.
+        if (readHolderPid(path) === process.pid) {
+          try { unlinkSync(path); } catch { /* already gone */ }
+        }
+        process.off("exit", release);
+      };
+      process.on("exit", release);
+      return { acquired: true, release };
+    } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code !== "EEXIST") throw e;
+
+      const holderPid = readHolderPid(path);
+      if (holderPid === undefined) {
+        // Lockfile present but PID not written yet (contender between
+        // openSync and writeFileSync) or content corrupt. Don't race to unlink.
+        return { acquired: false };
+      }
+      if (isProcessAlive(holderPid)) {
+        return { acquired: false, holderPid };
+      }
+      // Stale: holder is dead. Drop and retry once.
+      try { unlinkSync(path); } catch { /* lost the race; loop retries */ }
+    }
+  }
+
+  // Second attempt also lost the race — surface as contention without a PID.
+  return { acquired: false };
+}

package/src/bun/index.ts

@@ -1,7 +1,6 @@
 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";
 import { buniteEventEmitter } from "./events/eventEmitter";
 import { BuniteEvent } from "./events/event";
 import { completePermissionRequest } from "./proc/native";
@@ -13,17 +12,17 @@ import {
   type RpcSchema,
   type RpcWithTransport
 } from "../shared/rpc";
-import { createRpcTransportDemuxer, type RpcChannelHandle, type RpcTransportDemuxer, type RpcTransportDemuxerOptions } from "../shared/rpcDemux";
+import { createRpcTransportDemuxer, type RpcChannelHandle, type RpcDemuxBufferPolicy, type RpcTransportDemuxer, type RpcTransportDemuxerOptions } from "../shared/rpcDemux";
 import { createWebSocketTransport, type WebSocketLike, type WebSocketTransportPipe } from "../shared/webSocketTransport";
 import { createWebRpcHandler, type WebRpcClient } from "../shared/webRpcHandler";
-import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
+import { acquireSingleInstanceLock, type SingleInstanceLock } from "./core/singleInstanceLock";
 import { log, type LogLevel } from "../shared/log";
 
 export {
+  acquireSingleInstanceLock,
   AppRuntime,
   BrowserWindow,
   BrowserView,
-  Utils,
   buniteEventEmitter,
   completePermissionRequest,
   createRpc,
@@ -41,12 +40,12 @@ export type {
   BuniteRpcSchema,
   BrowserViewOptions,
   RpcChannelHandle,
-  MessageBoxOptions,
-  MessageBoxResponse,
+  RpcDemuxBufferPolicy,
   RpcSchema,
   RpcWithTransport,
   RpcTransportDemuxer,
   RpcTransportDemuxerOptions,
+  SingleInstanceLock,
   WebRpcClient,
   WebSocketLike,
   WebSocketTransportPipe,

package/src/bun/preload/inline.ts

@@ -53,8 +53,7 @@ function readCustomPreload(preload: string | null, appresRoot: string | null) {
   }
 }
 
-// Pre-built preload runtime (built via `bun run build:preload` in package/).
-// Embedded at bundle time so bun --compile includes it without filesystem access.
+// Bundled at build time so bun --compile works without filesystem access.
 // @ts-ignore — text import attribute
 import embeddedPreloadRuntime from "../../preload/runtime.built.js" with { type: "text" };
 

package/src/bun/proc/native.ts

@@ -9,7 +9,12 @@ export type NativeBootstrapOptions = {
   allowStub?: boolean;
   hideConsole?: boolean;
   popupBlocking?: boolean;
-  chromiumFlags?: Record<string, string | boolean>;
+  /**
+   * Engine-specific opaque config. Each adapter parses its own keys.
+   * - CEF (Windows): Chromium command-line flags as `Record<flag, value | true>`.
+   * - WKWebView, WebKitGTK: defined per adapter; refer to the adapter's bootstrap docs.
+   */
+  engineFlags?: Record<string, string | boolean>;
 };
 
 export type NativeRuntimeState = {
@@ -23,15 +28,17 @@ type CStringPointer = Pointer;
 
 type NativeSymbols = {
   bunite_abi_version: () => number;
+  bunite_engine_name: () => CString;
+  bunite_engine_version: () => CString;
   bunite_set_log_level: (level: number) => void;
   bunite_init: (
-    processHelperPath: CStringPointer,
-    cefDir: CStringPointer,
+    engineDir: CStringPointer,
     hideConsole: boolean,
     popupBlocking: boolean,
-    chromiumFlagsJson: CStringPointer
+    engineConfigJson: CStringPointer
   ) => boolean;
   bunite_run_loop: () => void;
+  bunite_pump_once: () => void;
   bunite_quit: () => void;
   bunite_free_cstring: (value: Pointer) => void;
   bunite_window_create: (
@@ -101,16 +108,6 @@ type NativeSymbols = {
   bunite_view_close_devtools: (viewId: number) => void;
   bunite_view_toggle_devtools: (viewId: number) => void;
   bunite_complete_permission_request: (requestId: number, state: number) => void;
-  bunite_show_message_box: (
-    windowId: number,
-    type: CStringPointer,
-    title: CStringPointer,
-    message: CStringPointer,
-    detail: CStringPointer,
-    buttons: CStringPointer,
-    defaultId: number,
-    cancelId: number
-  ) => number;
   bunite_set_webview_event_handler: (handler: JSCallback) => void;
   bunite_set_window_event_handler: (handler: JSCallback) => void;
 };
@@ -119,26 +116,35 @@ type LoadedNativeLibrary = {
   symbols: NativeSymbols;
 };
 
-const messageBoxButtonSeparator = "\x1f";
-const unsetCancelId = -1;
-
 const nativeSymbolDefinitions = {
   bunite_abi_version: {
     args: [],
     returns: FFIType.i32
   },
+  bunite_engine_name: {
+    args: [],
+    returns: FFIType.cstring
+  },
+  bunite_engine_version: {
+    args: [],
+    returns: FFIType.cstring
+  },
   bunite_set_log_level: {
     args: [FFIType.i32],
     returns: FFIType.void
   },
   bunite_init: {
-    args: [FFIType.cstring, FFIType.cstring, FFIType.bool, FFIType.bool, FFIType.cstring],
+    args: [FFIType.cstring, FFIType.bool, FFIType.bool, FFIType.cstring],
     returns: FFIType.bool
   },
   bunite_run_loop: {
     args: [],
     returns: FFIType.void
   },
+  bunite_pump_once: {
+    args: [],
+    returns: FFIType.void
+  },
   bunite_quit: {
     args: [],
     returns: FFIType.void
@@ -310,19 +316,6 @@ const nativeSymbolDefinitions = {
     args: [FFIType.u32, FFIType.u32],
     returns: FFIType.void
   },
-  bunite_show_message_box: {
-    args: [
-      FFIType.u32,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.cstring,
-      FFIType.i32,
-      FFIType.i32
-    ],
-    returns: FFIType.i32
-  },
   bunite_set_webview_event_handler: {
     args: [FFIType.function],
     returns: FFIType.void
@@ -361,9 +354,7 @@ export function toCString(value: string): CStringPointer {
   const normalized = value.endsWith("\0") ? value : `${value}\0`;
   const buffer = Buffer.from(normalized, "utf8");
 
-  // Keep recent CString buffers alive long enough for native code to copy them.
-  // This is not a long-term ownership model for retained native pointers, but it
-  // avoids immediate GC hazards across the current FFI call boundary.
+  // Keep recent CString buffers alive across the FFI call (not long-term retention).
   retainedCStringBuffers.push(buffer);
   if (retainedCStringBuffers.length > 1024) {
     retainedCStringBuffers.shift();
@@ -373,20 +364,21 @@ export function toCString(value: string): CStringPointer {
 }
 
 function applyEnvironment(artifacts: ResolvedNativeArtifacts) {
-  const cefBinaryDir = artifacts.cefDir && existsSync(join(artifacts.cefDir, "Release", "libcef.dll"))
-    ? join(artifacts.cefDir, "Release")
-    : artifacts.cefDir;
-  const cefResourceDir = artifacts.cefDir && existsSync(join(artifacts.cefDir, "Resources", "resources.pak"))
-    ? join(artifacts.cefDir, "Resources")
-    : artifacts.cefDir;
-
-  if (cefResourceDir && !process.env.ICU_DATA) {
-    process.env.ICU_DATA = cefResourceDir;
+  // CEF needs engine dir on PATH (libcef.dll) and ICU_DATA pointing at resources. Null for mac/linux.
+  const engineBinaryDir = artifacts.engineDir && existsSync(join(artifacts.engineDir, "Release", "libcef.dll"))
+    ? join(artifacts.engineDir, "Release")
+    : artifacts.engineDir;
+  const engineResourceDir = artifacts.engineDir && existsSync(join(artifacts.engineDir, "Resources", "resources.pak"))
+    ? join(artifacts.engineDir, "Resources")
+    : artifacts.engineDir;
+
+  if (engineResourceDir && !process.env.ICU_DATA) {
+    process.env.ICU_DATA = engineResourceDir;
   }
-  if (cefBinaryDir) {
+  if (engineBinaryDir) {
     const pathEntries = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
-    if (!pathEntries.includes(cefBinaryDir)) {
-      process.env.PATH = [cefBinaryDir, ...pathEntries].join(delimiter);
+    if (!pathEntries.includes(engineBinaryDir)) {
+      process.env.PATH = [engineBinaryDir, ...pathEntries].join(delimiter);
     }
   }
 }
@@ -594,10 +586,7 @@ export async function initNativeRuntime(
   const allowStub = options.allowStub ?? true;
   const artifacts = resolveNativeArtifacts();
   const hasNativeArtifacts = Boolean(
-    artifacts.nativeLibPath &&
-      artifacts.processHelperPath &&
-      existsSync(artifacts.nativeLibPath) &&
-      existsSync(artifacts.processHelperPath)
+    artifacts.nativeLibPath && existsSync(artifacts.nativeLibPath)
   );
 
   applyEnvironment(artifacts);
@@ -611,7 +600,7 @@ export async function initNativeRuntime(
   nativeLibrary = hasNativeArtifacts ? tryLoadNativeLibrary(artifacts) : null;
 
   if (nativeLibrary) {
-    const EXPECTED_ABI = 2;
+    const EXPECTED_ABI = 4;
     const nativeAbi = nativeLibrary.symbols.bunite_abi_version();
     if (nativeAbi !== EXPECTED_ABI) {
       throw new Error(
@@ -620,15 +609,14 @@ export async function initNativeRuntime(
       );
     }
     registerNativeCallbacks(nativeLibrary);
-    const chromiumFlagsJson = options.chromiumFlags
-      ? JSON.stringify(options.chromiumFlags)
+    const engineConfigJson = options.engineFlags
+      ? JSON.stringify(options.engineFlags)
       : "";
     const initOk = nativeLibrary.symbols.bunite_init(
-      toCString(artifacts.processHelperPath ?? ""),
-      toCString(artifacts.cefDir ?? ""),
+      toCString(artifacts.engineDir ?? ""),
       options.hideConsole ?? false,
       options.popupBlocking ?? false,
-      toCString(chromiumFlagsJson)
+      toCString(engineConfigJson)
     );
 
     if (!initOk) {
@@ -675,28 +663,16 @@ export function completePermissionRequest(requestId: number, stateValue: number)
   nativeLibrary?.symbols.bunite_complete_permission_request(requestId, stateValue);
 }
 
-export function showNativeMessageBox(windowId: number, params: {
-  type?: string;
-  title?: string;
-  message?: string;
-  detail?: string;
-  buttons?: string[];
-  defaultId?: number;
-  cancelId?: number;
-}): number {
+export function getNativeEngineName(): string | null {
   const native = getNativeLibrary();
-  if (!native) {
-    return params.cancelId ?? params.defaultId ?? 0;
-  }
+  if (!native) return null;
+  const cstr = native.symbols.bunite_engine_name();
+  return cstr.toString();
+}
 
-  return native.symbols.bunite_show_message_box(
-    windowId,
-    toCString(params.type ?? "info"),
-    toCString(params.title ?? ""),
-    toCString(params.message ?? ""),
-    toCString(params.detail ?? ""),
-    toCString((params.buttons ?? ["OK"]).join(messageBoxButtonSeparator)),
-    params.defaultId ?? 0,
-    params.cancelId ?? unsetCancelId
-  );
+export function getNativeEngineVersion(): string | null {
+  const native = getNativeLibrary();
+  if (!native) return null;
+  const cstr = native.symbols.bunite_engine_version();
+  return cstr.toString();
 }