bunite-core 0.0.1

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "bunite-core",
+  "description": "Uniting UI and Bun",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "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"
+  },
+  "exports": {
+    ".": "./src/bun/index.ts",
+    "./bun": "./src/bun/index.ts",
+    "./view": "./src/view/index.ts",
+    "./config": "./src/types/config.ts",
+    "./shared/rpc": "./src/shared/rpc.ts",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "msgpackr": "^1.11.9"
+  }
+}

package/src/bun/core/App.ts

@@ -0,0 +1,142 @@
+import { join } from "node:path";
+import { BuniteEvent } from "../events/event";
+import { buniteEventEmitter } from "../events/eventEmitter";
+import {
+  getNativeLibrary,
+  initNativeRuntime,
+  getNativeRuntimeState,
+  setRouteRequestHandler,
+  toCString,
+  type NativeBootstrapOptions
+} from "../proc/native";
+import { attachGlobalIPCResolver, ensureRPCServer } from "./Socket";
+
+type AppInitOptions = NativeBootstrapOptions & {
+  userDataDir?: string;
+};
+
+export type GlobalIPCHandler = (params: unknown, ctx: { viewId: number }) => unknown | Promise<unknown>;
+
+class AppRuntime {
+  private initPromise: Promise<void> | null = null;
+  private stubKeepAliveTimer: ReturnType<typeof setInterval> | null = null;
+  private readonly globalIPCHandlers = new Map<string, GlobalIPCHandler>();
+
+  async init(options: AppInitOptions = {}) {
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        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");
+        }
+
+        const runtime = await initNativeRuntime({
+          allowStub: options.allowStub,
+          hideConsole: options.hideConsole,
+          popupBlocking: options.popupBlocking,
+          chromiumFlags: options.chromiumFlags
+        });
+
+        attachGlobalIPCResolver((channel) => this.getGlobalIPCHandler(channel));
+        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));
+        }
+
+        ensureRPCServer();
+        buniteEventEmitter.emitEvent(
+          new BuniteEvent("ready", {
+            usingStub: runtime.usingStub,
+            artifacts: runtime.artifacts
+          })
+        );
+      })();
+    }
+
+    await this.initPromise;
+  }
+
+  on(name: string, handler: (payload: unknown) => void) {
+    const wrapped = (event: { data: unknown }) => handler(event.data);
+    buniteEventEmitter.on(name, wrapped);
+    return () => buniteEventEmitter.off(name, wrapped);
+  }
+
+  run() {
+    const runtime = getNativeRuntimeState();
+    if (runtime?.nativeLoaded) {
+      getNativeLibrary()?.symbols.bunite_run_loop();
+      if (!this.stubKeepAliveTimer) {
+        this.stubKeepAliveTimer = setInterval(() => {}, 60_000);
+      }
+      return;
+    }
+
+    if (!this.stubKeepAliveTimer) {
+      console.warn("[bunite] Running without a native event loop. Keeping the process alive in stub mode.");
+      this.stubKeepAliveTimer = setInterval(() => {}, 60_000);
+    }
+  }
+
+  quit(code = 0) {
+    if (this.stubKeepAliveTimer) {
+      clearInterval(this.stubKeepAliveTimer);
+      this.stubKeepAliveTimer = null;
+    }
+    getNativeLibrary()?.symbols.bunite_quit();
+    setTimeout(() => process.exit(code), 0);
+  }
+
+  handle(channel: string, handler: GlobalIPCHandler) {
+    if (channel.startsWith("__bunite:")) {
+      throw new Error(`Channel prefix "__bunite:" is reserved: ${channel}`);
+    }
+    if (this.globalIPCHandlers.has(channel)) {
+      throw new Error(`Global IPC handler already registered for: ${channel}`);
+    }
+    this.globalIPCHandlers.set(channel, handler);
+    return () => this.globalIPCHandlers.delete(channel);
+  }
+
+  removeHandler(channel: string) {
+    this.globalIPCHandlers.delete(channel);
+  }
+
+  /** @internal */
+  getGlobalIPCHandler(channel: string): GlobalIPCHandler | undefined {
+    return this.globalIPCHandlers.get(channel);
+  }
+
+  private readonly viewHandlers = new Map<string, () => string>();
+
+  getView(path: string, handler: () => string) {
+    this.viewHandlers.set(path, handler);
+    getNativeLibrary()?.symbols.bunite_register_view_route(toCString(path));
+  }
+
+  removeView(path: string) {
+    this.viewHandlers.delete(path);
+    getNativeLibrary()?.symbols.bunite_unregister_view_route(toCString(path));
+  }
+
+  /** @internal */
+  handleRouteRequest(requestId: number, path: string) {
+    let html: string;
+    try {
+      const handler = this.viewHandlers.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>";
+    }
+    getNativeLibrary()?.symbols.bunite_complete_route_request(requestId, toCString(html));
+  }
+
+  get runtime() {
+    return getNativeRuntimeState();
+  }
+}
+
+export const app = new AppRuntime();

package/src/bun/core/BrowserView.ts

@@ -0,0 +1,262 @@
+import { buildViewPreloadScript } from "../preload/inline";
+import type { Pointer } from "bun:ffi";
+import { buniteEventEmitter } from "../events/eventEmitter";
+import { defineBuniteRPC, type BuniteRPCConfig, type BuniteRPCSchema, type RPCWithTransport } from "../../shared/rpc";
+import { ensureNativeRuntime, getNativeLibrary, toCString } from "../proc/native";
+import { attachBrowserViewRegistry, getRPCPort, sendMessageToView } from "./Socket";
+import { randomBytes } from "node:crypto";
+import { resolveDefaultViewsRoot } from "../../shared/paths";
+
+const BrowserViewMap: Record<number, BrowserView<any>> = {};
+let nextWebviewId = 1;
+
+export type BrowserViewOptions<T = undefined> = {
+  url: string | null;
+  html: string | null;
+  preload: string | null;
+  viewsRoot: string | null;
+  partition: string | null;
+  windowPtr?: Pointer | null;
+  frame: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  rpc?: T;
+  windowId: number;
+  autoResize: boolean;
+  navigationRules: string[] | null;
+  sandbox: boolean;
+};
+
+const defaultOptions: BrowserViewOptions = {
+  url: null,
+  html: null,
+  preload: null,
+  viewsRoot: null,
+  partition: null,
+  windowPtr: null,
+  frame: {
+    x: 0,
+    y: 0,
+    width: 800,
+    height: 600
+  },
+  windowId: 0,
+  autoResize: true,
+  navigationRules: null,
+  sandbox: false
+};
+
+export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
+  id = nextWebviewId++;
+  ptr: Pointer | null = null;
+  windowId: number;
+  url: string | null;
+  html: string | null;
+  preload: string | null;
+  viewsRoot: string | null;
+  partition: string | null;
+  frame: BrowserViewOptions["frame"];
+  rpc?: T;
+  rpcHandler?: (message: unknown) => void;
+  autoResize: boolean;
+  navigationRules: string[] | null;
+  sandbox: boolean;
+  secretKey: Uint8Array;
+
+  constructor(options: Partial<BrowserViewOptions<T>>) {
+    ensureNativeRuntime();
+
+    this.windowId = options.windowId ?? defaultOptions.windowId;
+    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.partition = options.partition ?? defaultOptions.partition;
+    this.frame = options.frame ?? defaultOptions.frame;
+    this.rpc = options.rpc;
+    this.autoResize = options.autoResize ?? defaultOptions.autoResize;
+    this.navigationRules = options.navigationRules ?? defaultOptions.navigationRules;
+    this.sandbox = options.sandbox ?? defaultOptions.sandbox;
+    this.secretKey = new Uint8Array(randomBytes(32));
+
+    if (this.sandbox) {
+      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.");
+    }
+
+    const preloadScript = buildViewPreloadScript({
+      preload: this.preload,
+      viewsRoot: this.viewsRoot,
+      webviewId: this.id,
+      rpcSocketPort: getRPCPort(),
+      secretKey: this.secretKey
+    });
+
+    BrowserViewMap[this.id] = this;
+    this.rpc?.setTransport(this.createTransport());
+    this.ptr =
+      getNativeLibrary()?.symbols.bunite_view_create(
+        this.id,
+        options.windowPtr ?? null,
+        toCString(this.url ?? ""),
+        toCString(this.html ?? ""),
+        toCString(preloadScript),
+        toCString(this.viewsRoot ?? ""),
+        toCString(this.navigationRules ? JSON.stringify(this.navigationRules) : ""),
+        this.frame.x,
+        this.frame.y,
+        this.frame.width,
+        this.frame.height,
+        this.autoResize,
+        this.sandbox
+      ) ?? null;
+  }
+
+  static getById(id: number) {
+    return BrowserViewMap[id];
+  }
+
+  static getAll() {
+    return Object.values(BrowserViewMap);
+  }
+
+  static defineRPC<Schema extends BuniteRPCSchema>(
+    config: BuniteRPCConfig<Schema, "bun">
+  ) {
+    return defineBuniteRPC("bun", config);
+  }
+
+  handleIncomingRPC(message: unknown) {
+    this.rpcHandler?.(message);
+  }
+
+  createTransport() {
+    return {
+      send: (message: any) => {
+        sendMessageToView(this.id, message);
+      },
+      registerHandler: (handler: (message: any) => void) => {
+        this.rpcHandler = handler;
+      },
+      unregisterHandler: () => {
+        this.rpcHandler = undefined;
+      }
+    };
+  }
+
+  get rpcPort() {
+    return getRPCPort();
+  }
+
+  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);
+    }
+  }
+
+  goBack() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_go_back(this.ptr);
+    }
+  }
+
+  reload() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_reload(this.ptr);
+    }
+  }
+
+  setVisible(visible: boolean) {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_set_visible(this.ptr, visible);
+    }
+  }
+
+  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);
+    }
+  }
+
+  loadURL(url: string) {
+    this.url = url;
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_load_url(this.ptr, toCString(url));
+    }
+  }
+
+  loadHTML(html: string) {
+    this.html = html;
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_load_html(this.ptr, toCString(html));
+    }
+  }
+
+  remove() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_remove(this.ptr);
+    }
+    this.detachFromNative();
+  }
+
+  openDevTools() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_open_devtools(this.ptr);
+    }
+  }
+
+  closeDevTools() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_close_devtools(this.ptr);
+    }
+  }
+
+  toggleDevTools() {
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_view_toggle_devtools(this.ptr);
+    }
+  }
+
+  detachFromNative() {
+    this.ptr = null;
+    for (const eventName of [
+      "will-navigate",
+      "did-navigate",
+      "dom-ready",
+      "new-window-open",
+      "permission-requested",
+      "message-box-response"
+    ]) {
+      buniteEventEmitter.removeAllListeners(`${eventName}-${this.id}`);
+    }
+    delete BrowserViewMap[this.id];
+  }
+
+  on(
+    name:
+      | "will-navigate"
+      | "did-navigate"
+      | "dom-ready"
+      | "new-window-open"
+      | "permission-requested"
+      | "message-box-response",
+    handler: (event: unknown) => void
+  ) {
+    const specificName = `${name}-${this.id}`;
+    buniteEventEmitter.on(specificName, handler);
+    return () => buniteEventEmitter.off(specificName, handler);
+  }
+}
+
+attachBrowserViewRegistry({
+  getById(id) {
+    return BrowserView.getById(id);
+  }
+});