bunite-core 0.0.1

package/src/bun/core/BrowserWindow.ts

@@ -0,0 +1,322 @@
+import type { Pointer } from "bun:ffi";
+import { BuniteEvent } from "../events/event";
+import { buniteEventEmitter } from "../events/eventEmitter";
+import { ensureNativeRuntime, getNativeLibrary, toCString } from "../proc/native";
+import { BrowserView, type BrowserViewOptions } from "./BrowserView";
+import type { RPCWithTransport } from "../../shared/rpc";
+import { getNextWindowId } from "./windowIds";
+import { resolveDefaultViewsRoot } from "../../shared/paths";
+
+export type WindowOptionsType<T = undefined> = {
+  title: string;
+  frame: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    maximized?: boolean;
+    minimized?: boolean;
+  };
+  url: string | null;
+  html: string | null;
+  preload: string | null;
+  viewsRoot: string | null;
+  rpc?: T;
+  titleBarStyle: "hidden" | "hiddenInset" | "default";
+  transparent: boolean;
+  hidden?: boolean;
+  navigationRules: string[] | null;
+  sandbox: boolean;
+};
+
+const defaultOptions: WindowOptionsType = {
+  title: "bunite",
+  frame: {
+    x: 80,
+    y: 80,
+    width: 1280,
+    height: 900
+  },
+  url: null,
+  html: null,
+  preload: null,
+  viewsRoot: null,
+  titleBarStyle: "default",
+  transparent: false,
+  hidden: false,
+  navigationRules: null,
+  sandbox: false
+};
+
+const BrowserWindowMap: Record<number, BrowserWindow<any>> = {};
+
+export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
+  id = getNextWindowId();
+  ptr: Pointer | null = null;
+  title: string;
+  frame: WindowOptionsType["frame"];
+  url: string | null;
+  html: string | null;
+  preload: string | null;
+  viewsRoot: string | null;
+  titleBarStyle: WindowOptionsType["titleBarStyle"];
+  transparent: boolean;
+  hidden: boolean;
+  navigationRules: string[] | null;
+  sandbox: boolean;
+  webviewId: number;
+  private closed = false;
+  private restoreMaximizedAfterMinimize = false;
+  private readonly handleNativeMove = (event: unknown) => {
+    const data = (event as {
+      data?: { x?: number; y?: number; maximized?: boolean; minimized?: boolean };
+    }).data;
+    if (!data) {
+      return;
+    }
+
+    this.frame = {
+      ...this.frame,
+      x: data.x ?? this.frame.x,
+      y: data.y ?? this.frame.y,
+      maximized: data.maximized ?? this.frame.maximized,
+      minimized: data.minimized ?? this.frame.minimized
+    };
+  };
+  private readonly handleNativeResize = (event: unknown) => {
+    const data = (event as {
+      data?: { x?: number; y?: number; width?: number; height?: number; maximized?: boolean; minimized?: boolean };
+    }).data;
+    if (!data) {
+      return;
+    }
+
+    this.frame = {
+      ...this.frame,
+      x: data.x ?? this.frame.x,
+      y: data.y ?? this.frame.y,
+      width: data.width ?? this.frame.width,
+      height: data.height ?? this.frame.height,
+      maximized: data.maximized ?? this.frame.maximized,
+      minimized: data.minimized ?? this.frame.minimized
+    };
+  };
+  private readonly handleNativeClose = () => {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.ptr = null;
+    BrowserView.getById(this.webviewId)?.detachFromNative();
+    delete BrowserWindowMap[this.id];
+    buniteEventEmitter.off(`move-${this.id}`, this.handleNativeMove);
+    buniteEventEmitter.off(`resize-${this.id}`, this.handleNativeResize);
+    buniteEventEmitter.off(`close-${this.id}`, this.handleNativeClose);
+  };
+
+  constructor(options: Partial<WindowOptionsType<T>> = {}) {
+    ensureNativeRuntime();
+
+    this.title = options.title ?? defaultOptions.title;
+    this.frame = { ...defaultOptions.frame, ...options.frame };
+    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.titleBarStyle = options.titleBarStyle ?? defaultOptions.titleBarStyle;
+    this.transparent = options.transparent ?? defaultOptions.transparent;
+    this.hidden = options.hidden ?? defaultOptions.hidden!;
+    this.navigationRules = options.navigationRules ?? defaultOptions.navigationRules;
+    this.sandbox = options.sandbox ?? defaultOptions.sandbox;
+
+    const native = getNativeLibrary();
+    this.ptr =
+      native?.symbols.bunite_window_create(
+        this.id,
+        this.frame.x,
+        this.frame.y,
+        this.frame.width,
+        this.frame.height,
+        toCString(this.title),
+        toCString(this.titleBarStyle),
+        this.transparent,
+        this.hidden,
+        Boolean(this.frame.minimized),
+        Boolean(this.frame.maximized)
+      ) ?? null;
+
+    BrowserWindowMap[this.id] = this;
+    buniteEventEmitter.on(`move-${this.id}`, this.handleNativeMove);
+    buniteEventEmitter.on(`resize-${this.id}`, this.handleNativeResize);
+    buniteEventEmitter.on(`close-${this.id}`, this.handleNativeClose);
+
+    const webview = new BrowserView({
+      url: this.url,
+      html: this.html,
+      preload: this.preload,
+      viewsRoot: this.viewsRoot,
+      windowPtr: this.ptr,
+      frame: {
+        x: 0,
+        y: 0,
+        width: this.frame.width,
+        height: this.frame.height
+      },
+      rpc: options.rpc as BrowserViewOptions<T>["rpc"],
+      windowId: this.id,
+      navigationRules: this.navigationRules,
+      sandbox: this.sandbox
+    });
+
+    this.webviewId = webview.id;
+  }
+
+  static getById(id: number) {
+    return BrowserWindowMap[id];
+  }
+
+  get webview() {
+    return BrowserView.getById(this.webviewId) as BrowserView<T>;
+  }
+
+  show() {
+    this.hidden = false;
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_window_show(this.ptr);
+    }
+  }
+
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    const hadNativePtr = Boolean(this.ptr);
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_window_close(this.ptr);
+      this.ptr = null;
+    } else {
+      BrowserView.getById(this.webviewId)?.remove();
+    }
+    delete BrowserWindowMap[this.id];
+    buniteEventEmitter.off(`move-${this.id}`, this.handleNativeMove);
+    buniteEventEmitter.off(`resize-${this.id}`, this.handleNativeResize);
+    buniteEventEmitter.off(`close-${this.id}`, this.handleNativeClose);
+    if (!hadNativePtr) {
+      buniteEventEmitter.emitEvent(buniteEventEmitter.events.window.close({ id: this.id }), this.id);
+    }
+  }
+
+  maximize() {
+    if (!this.ptr) {
+      this.frame.maximized = true;
+      this.frame.minimized = false;
+      return;
+    }
+
+    const native = getNativeLibrary();
+    if (!native) {
+      return;
+    }
+
+    native.symbols.bunite_window_maximize(this.ptr);
+    this.frame.minimized = native.symbols.bunite_window_is_minimized(this.ptr);
+    this.frame.maximized = native.symbols.bunite_window_is_maximized(this.ptr);
+  }
+
+  unmaximize() {
+    if (!this.ptr) {
+      this.frame.maximized = false;
+      return;
+    }
+
+    const native = getNativeLibrary();
+    if (!native) {
+      return;
+    }
+
+    native.symbols.bunite_window_unmaximize(this.ptr);
+    this.frame.minimized = native.symbols.bunite_window_is_minimized(this.ptr);
+    this.frame.maximized = native.symbols.bunite_window_is_maximized(this.ptr);
+  }
+
+  isMaximized() {
+    if (!this.ptr) {
+      return Boolean(this.frame.maximized);
+    }
+
+    const maximized = getNativeLibrary()?.symbols.bunite_window_is_maximized(this.ptr) ?? false;
+    this.frame.maximized = maximized;
+    return maximized;
+  }
+
+  minimize() {
+    if (!this.ptr) {
+      this.restoreMaximizedAfterMinimize = Boolean(this.frame.maximized);
+      this.frame.minimized = true;
+      this.frame.maximized = false;
+      return;
+    }
+
+    const native = getNativeLibrary();
+    if (!native) {
+      return;
+    }
+
+    native.symbols.bunite_window_minimize(this.ptr);
+    this.frame.minimized = native.symbols.bunite_window_is_minimized(this.ptr);
+    this.frame.maximized = native.symbols.bunite_window_is_maximized(this.ptr);
+  }
+
+  unminimize() {
+    if (!this.ptr) {
+      this.frame.minimized = false;
+      this.frame.maximized = this.restoreMaximizedAfterMinimize;
+      this.restoreMaximizedAfterMinimize = false;
+      return;
+    }
+
+    const native = getNativeLibrary();
+    if (!native) {
+      return;
+    }
+
+    native.symbols.bunite_window_unminimize(this.ptr);
+    this.frame.minimized = native.symbols.bunite_window_is_minimized(this.ptr);
+    this.frame.maximized = native.symbols.bunite_window_is_maximized(this.ptr);
+  }
+
+  isMinimized() {
+    if (!this.ptr) {
+      return Boolean(this.frame.minimized);
+    }
+
+    const minimized = getNativeLibrary()?.symbols.bunite_window_is_minimized(this.ptr) ?? false;
+    this.frame.minimized = minimized;
+    return minimized;
+  }
+
+  setTitle(title: string) {
+    this.title = title;
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_window_set_title(this.ptr, toCString(title));
+    }
+  }
+
+  setFrame(x: number, y: number, width: number, height: number) {
+    this.frame = { ...this.frame, x, y, width, height };
+    if (this.ptr) {
+      getNativeLibrary()?.symbols.bunite_window_set_frame(this.ptr, x, y, width, height);
+    }
+  }
+
+  getFrame() {
+    return this.frame;
+  }
+
+  on(name: "close" | "focus" | "blur" | "move" | "resize", handler: (event: unknown) => void) {
+    const specificName = `${name}-${this.id}`;
+    buniteEventEmitter.on(specificName, handler);
+    return () => buniteEventEmitter.off(specificName, handler);
+  }
+}

package/src/bun/core/Socket.ts

@@ -0,0 +1,186 @@
+import type { Server, ServerWebSocket } from "bun";
+import type { BrowserView } from "./BrowserView";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import type { RPCPacket, RPCRequestPacket } from "../../shared/rpc";
+import type { GlobalIPCHandler } from "./App";
+import {
+  asUint8Array,
+  createEncryptedRPCFrame,
+  decodeRPCPacket,
+  encodeRPCPacket,
+  parseEncryptedRPCFrame
+} from "../../shared/rpcWire";
+import { RPC_AUTH_TAG_LENGTH } from "../../shared/rpcWireConstants";
+
+type ViewRegistry = {
+  getById(id: number): BrowserView | undefined;
+};
+
+type WebSocketData = {
+  webviewId: number;
+};
+
+let rpcServer: Server<WebSocketData> | null = null;
+let rpcPort = 0;
+
+const socketMap: Record<number, ServerWebSocket<WebSocketData> | null> = {};
+let registry: ViewRegistry | null = null;
+let globalIPCResolver: ((channel: string) => GlobalIPCHandler | undefined) | null = null;
+
+export function attachGlobalIPCResolver(resolver: (channel: string) => GlobalIPCHandler | undefined) {
+  globalIPCResolver = resolver;
+}
+
+function encrypt(secretKey: Uint8Array, payload: Uint8Array) {
+  const iv = new Uint8Array(randomBytes(12));
+  const cipher = createCipheriv("aes-256-gcm", secretKey, iv);
+  const encrypted = Buffer.concat([cipher.update(payload), cipher.final(), cipher.getAuthTag()]);
+  return createEncryptedRPCFrame(iv, new Uint8Array(encrypted));
+}
+
+function decrypt(secretKey: Uint8Array, frame: Uint8Array) {
+  const { iv, encryptedPayload } = parseEncryptedRPCFrame(frame);
+  const ciphertext = encryptedPayload.subarray(0, encryptedPayload.byteLength - RPC_AUTH_TAG_LENGTH);
+  const tag = encryptedPayload.subarray(encryptedPayload.byteLength - RPC_AUTH_TAG_LENGTH);
+  const decipher = createDecipheriv("aes-256-gcm", secretKey, iv);
+  decipher.setAuthTag(tag);
+  return new Uint8Array(Buffer.concat([decipher.update(ciphertext), decipher.final()]));
+}
+
+function normalizeIncomingBinaryMessage(
+  message: string | ArrayBuffer | Uint8Array | Buffer
+): Uint8Array | null {
+  if (typeof message === "string") {
+    return null;
+  }
+  return asUint8Array(message);
+}
+
+export function attachBrowserViewRegistry(nextRegistry: ViewRegistry) {
+  registry = nextRegistry;
+}
+
+export function ensureRPCServer() {
+  if (rpcServer) {
+    return { rpcServer, rpcPort };
+  }
+
+  let port = 45000;
+  while (port <= 65535) {
+    try {
+      rpcServer = Bun.serve<WebSocketData>({
+        hostname: "127.0.0.1",
+        port,
+        fetch(req, server) {
+          const url = new URL(req.url);
+          if (url.pathname !== "/socket") {
+            return new Response("Not found", { status: 404 });
+          }
+
+          const webviewId = Number(url.searchParams.get("webviewId"));
+          if (!Number.isFinite(webviewId)) {
+            return new Response("Missing webviewId", { status: 400 });
+          }
+          if (!registry?.getById(webviewId)) {
+            return new Response("Unknown webviewId", { status: 403 });
+          }
+
+          const upgraded = server.upgrade(req, {
+            data: { webviewId }
+          });
+          return upgraded ? undefined : new Response("Upgrade failed", { status: 500 });
+        },
+        websocket: {
+          open(ws) {
+            socketMap[ws.data.webviewId] = ws;
+          },
+          close(ws) {
+            socketMap[ws.data.webviewId] = null;
+          },
+          message(ws, message) {
+            const view = registry?.getById(ws.data.webviewId);
+            const binaryMessage = normalizeIncomingBinaryMessage(message);
+            if (!view || !binaryMessage) {
+              return;
+            }
+            try {
+              const decryptedMessage = decrypt(view.secretKey, binaryMessage);
+              const packet = decodeRPCPacket(decryptedMessage);
+
+              if (packet.type === "request" && (packet as RPCRequestPacket).scope === "global") {
+                void handleGlobalIPC(packet as RPCRequestPacket, ws.data.webviewId);
+                return;
+              }
+
+              view.handleIncomingRPC(packet);
+            } catch (error) {
+              console.error("[bunite] Failed to parse RPC payload", error);
+            }
+          }
+        }
+      });
+      rpcPort = port;
+      break;
+    } catch (error: any) {
+      if (error?.code === "EADDRINUSE") {
+        port += 1;
+        continue;
+      }
+      throw error;
+    }
+  }
+
+  if (!rpcServer) {
+    throw new Error("Could not start bunite RPC server.");
+  }
+
+  return { rpcServer, rpcPort };
+}
+
+export function getRPCPort(): number {
+  return rpcPort;
+}
+
+async function handleGlobalIPC(packet: RPCRequestPacket, viewId: number) {
+  const handler = globalIPCResolver?.(packet.method);
+  if (!handler) {
+    sendMessageToView(viewId, {
+      type: "response",
+      id: packet.id,
+      success: false,
+      error: `No handler registered for: ${packet.method}`,
+      scope: "global"
+    });
+    return;
+  }
+  try {
+    const result = await handler(packet.params, { viewId });
+    sendMessageToView(viewId, {
+      type: "response",
+      id: packet.id,
+      success: true,
+      payload: result,
+      scope: "global"
+    });
+  } catch (error) {
+    sendMessageToView(viewId, {
+      type: "response",
+      id: packet.id,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      scope: "global"
+    });
+  }
+}
+
+export function sendMessageToView(viewId: number, message: RPCPacket): boolean {
+  const socket = socketMap[viewId];
+  const view = registry?.getById(viewId);
+  if (!socket || socket.readyState !== WebSocket.OPEN || !view) {
+    return false;
+  }
+
+  const encrypted = encrypt(view.secretKey, encodeRPCPacket(message));
+  socket.send(encrypted);
+  return true;
+}

package/src/bun/core/Utils.ts

@@ -0,0 +1,72 @@
+import { buniteEventEmitter } from "../events/eventEmitter";
+import {
+  cancelBrowserMessageBoxRequest,
+  ensureNativeRuntime,
+  getNativeLibrary,
+  requestBrowserMessageBox,
+  showNativeMessageBox
+} from "../proc/native";
+
+export type MessageBoxOptions = {
+  type?: "none" | "info" | "warning" | "error" | "question";
+  title?: string;
+  message?: string;
+  detail?: string;
+  buttons?: string[];
+  defaultId?: number;
+  cancelId?: number;
+};
+
+export type MessageBoxResponse = {
+  response: number;
+};
+
+export async function showMessageBox(
+  options: MessageBoxOptions = {}
+): Promise<MessageBoxResponse> {
+  ensureNativeRuntime();
+
+  if (!getNativeLibrary()) {
+    console.warn(
+      "[bunite] Utils.showMessageBox() requires the native runtime. Returning a stub response."
+    );
+    return {
+      response: options.cancelId ?? options.defaultId ?? 0
+    };
+  }
+
+  const requestId = requestBrowserMessageBox(options);
+  if (requestId > 0) {
+const response = await new Promise<number>((resolve) => {
+      const fallbackResponse = options.cancelId ?? options.defaultId ?? 0;
+      const handleResponse = (event: unknown) => {
+        const data = (event as { data?: { requestId?: number; response?: number } }).data;
+        if (!data || data.requestId !== requestId) {
+          return;
+        }
+
+        clearTimeout(timeoutId);
+        buniteEventEmitter.off("message-box-response", handleResponse);
+        resolve(
+          typeof data.response === "number" && data.response >= 0
+            ? data.response
+            : fallbackResponse
+        );
+      };
+
+      const timeoutId = setTimeout(() => {
+        buniteEventEmitter.off("message-box-response", handleResponse);
+        cancelBrowserMessageBoxRequest(requestId);
+        resolve(fallbackResponse);
+      }, 15_000);
+
+      buniteEventEmitter.on("message-box-response", handleResponse);
+    });
+
+    return { response };
+  }
+
+  return {
+    response: showNativeMessageBox(options)
+  };
+}

package/src/bun/core/windowIds.ts

@@ -0,0 +1,7 @@
+let nextWindowId = 1;
+
+export function getNextWindowId() {
+  const id = nextWindowId;
+  nextWindowId += 1;
+  return id;
+}

package/src/bun/events/appEvents.ts

@@ -0,0 +1,7 @@
+import { BuniteEvent } from "./event";
+
+export default {
+  ready: (data: Record<string, unknown>) => new BuniteEvent("ready", data),
+  beforeQuit: (data: Record<string, unknown>) =>
+    new BuniteEvent<Record<string, unknown>, { allow?: boolean }>("before-quit", data)
+};

package/src/bun/events/event.ts

@@ -0,0 +1,20 @@
+export class BuniteEvent<Data = unknown, Response = unknown> {
+  name: string;
+  data: Data;
+  private _response: Response | undefined;
+  responseWasSet = false;
+
+  constructor(name: string, data: Data) {
+    this.name = name;
+    this.data = data;
+  }
+
+  get response(): Response | undefined {
+    return this._response;
+  }
+
+  set response(value: Response) {
+    this._response = value;
+    this.responseWasSet = true;
+  }
+}

package/src/bun/events/eventEmitter.ts

@@ -0,0 +1,28 @@
+import EventEmitter from "node:events";
+import { BuniteEvent } from "./event";
+import appEvents from "./appEvents";
+import windowEvents from "./windowEvents";
+import webviewEvents from "./webviewEvents";
+
+class BuniteEventEmitter extends EventEmitter {
+  emitEvent(event: BuniteEvent, specifier?: string | number) {
+    if (specifier !== undefined) {
+      this.emit(`${event.name}-${specifier}`, event);
+    }
+    this.emit(event.name, event);
+  }
+
+  events = {
+    app: {
+      ...appEvents
+    },
+    window: {
+      ...windowEvents
+    },
+    webview: {
+      ...webviewEvents
+    }
+  };
+}
+
+export const buniteEventEmitter = new BuniteEventEmitter();

package/src/bun/events/webviewEvents.ts

@@ -0,0 +1,13 @@
+import { BuniteEvent } from "./event";
+
+export default {
+  willNavigate: (data: { detail: string }) => new BuniteEvent("will-navigate", data),
+  didNavigate: (data: { detail: string }) => new BuniteEvent("did-navigate", data),
+  domReady: (data: { detail: string }) => new BuniteEvent("dom-ready", data),
+  newWindowOpen: (data: { detail: string | { url: string } }) =>
+    new BuniteEvent("new-window-open", data),
+  permissionRequested: (data: { requestId: number; kind: number; url?: string }) =>
+    new BuniteEvent("permission-requested", data),
+  messageBoxResponse: (data: { requestId: number; response: number }) =>
+    new BuniteEvent("message-box-response", data)
+};

package/src/bun/events/windowEvents.ts

@@ -0,0 +1,19 @@
+import { BuniteEvent } from "./event";
+
+export default {
+  close: (data: { id: number }) => new BuniteEvent("close", data),
+  focus: (data: { id: number }) => new BuniteEvent("focus", data),
+  blur: (data: { id: number }) => new BuniteEvent("blur", data),
+  move: (data: { id: number; x: number; y: number; maximized: boolean; minimized: boolean }) =>
+    new BuniteEvent("move", data),
+  resize: (data: {
+    id: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    maximized: boolean;
+    minimized: boolean;
+  }) =>
+    new BuniteEvent("resize", data)
+};