bunite-core 0.0.1

package/src/shared/rpc.ts

@@ -0,0 +1,399 @@
+export type RPCRequestPacket = {
+  type: "request";
+  id: number;
+  method: string;
+  params: unknown;
+  scope?: "global";
+};
+
+export type RPCResponsePacket =
+  | { type: "response"; id: number; success: true; payload: unknown; scope?: "global" }
+  | { type: "response"; id: number; success: false; error?: string; scope?: "global" };
+
+export type RPCMessagePacket = {
+  type: "message";
+  id: string;
+  payload: unknown;
+};
+
+export type RPCPacket = RPCRequestPacket | RPCResponsePacket | RPCMessagePacket;
+
+type BaseRPCRequestsSchema = Record<string, { params: unknown; response: unknown }>;
+type BaseRPCMessagesSchema = Record<string, unknown>;
+
+export type RPCRequestsSchema<T extends BaseRPCRequestsSchema = BaseRPCRequestsSchema> = T;
+export type RPCMessagesSchema<T extends BaseRPCMessagesSchema = BaseRPCMessagesSchema> = T;
+
+type InputRPCSchema = {
+  requests?: RPCRequestsSchema;
+  messages?: RPCMessagesSchema;
+};
+
+type ResolvedRPCSchema<I extends InputRPCSchema> = {
+  requests: undefined extends I["requests"] ? BaseRPCRequestsSchema : NonNullable<I["requests"]>;
+  messages: undefined extends I["messages"] ? BaseRPCMessagesSchema : NonNullable<I["messages"]>;
+};
+
+export type RPCSchema<I extends InputRPCSchema | void = InputRPCSchema> = ResolvedRPCSchema<
+  I extends InputRPCSchema ? I : InputRPCSchema
+>;
+
+type RequestParams<RS extends RPCRequestsSchema, M extends keyof RS> = RS[M]["params"];
+type RequestResponse<RS extends RPCRequestsSchema, M extends keyof RS> = RS[M]["response"];
+type MessagePayload<MS extends RPCMessagesSchema, N extends keyof MS> = MS[N];
+
+type RPCRequestHandlerFn<RS extends RPCRequestsSchema> = <M extends keyof RS>(
+  method: M,
+  params: RequestParams<RS, M>
+) => Promise<RequestResponse<RS, M>> | RequestResponse<RS, M>;
+
+type RPCRequestHandlerObject<RS extends RPCRequestsSchema> = {
+  [M in keyof RS]?: (
+    ...args: undefined extends RS[M]["params"] ? [params?: RS[M]["params"]] : [params: RS[M]["params"]]
+  ) => Promise<Awaited<RequestResponse<RS, M>>> | Awaited<RequestResponse<RS, M>>;
+} & {
+  _?: (method: keyof RS, params: RequestParams<RS, keyof RS>) => unknown;
+};
+
+export type RPCRequestHandler<RS extends RPCRequestsSchema = RPCRequestsSchema> =
+  | RPCRequestHandlerFn<RS>
+  | RPCRequestHandlerObject<RS>;
+
+export type RPCTransport = {
+  send?: (data: RPCPacket) => void;
+  registerHandler?: (handler: (packet: RPCPacket) => void) => void;
+  unregisterHandler?: () => void;
+};
+
+export interface RPCWithTransport {
+  setTransport: (transport: RPCTransport) => void;
+}
+
+export type BuniteRPCSchema = {
+  bun: RPCSchema;
+  webview: RPCSchema;
+};
+
+export type BuniteRPCConfig<
+  Schema extends BuniteRPCSchema,
+  Side extends "bun" | "webview"
+> = {
+  maxRequestTime?: number;
+  handlers: {
+    requests?: RPCRequestHandler<Schema[Side]["requests"]>;
+    messages?: {
+      [K in keyof Schema[Side]["messages"]]?: (
+        payload: MessagePayload<Schema[Side]["messages"], K>
+      ) => void;
+    } & {
+      "*"?: (
+        messageName: keyof Schema[Side]["messages"],
+        payload: MessagePayload<Schema[Side]["messages"], keyof Schema[Side]["messages"]>
+      ) => void;
+    };
+  };
+};
+
+const MAX_ID = 1e10;
+const DEFAULT_MAX_REQUEST_TIME = 15_000;
+
+function missingTransportMethodError(methods: string[], action: string): Error {
+  return new Error(
+    `This RPC instance cannot ${action} because the transport did not provide: ${methods.join(", ")}`
+  );
+}
+
+export function createRPC<
+  Schema extends RPCSchema = RPCSchema,
+  RemoteSchema extends RPCSchema = Schema
+>(options: {
+  transport?: RPCTransport;
+  requestHandler?: RPCRequestHandler<Schema["requests"]>;
+  maxRequestTime?: number;
+} = {}) {
+  let transport: RPCTransport = {};
+  let requestHandler:
+    | RPCRequestHandlerFn<Schema["requests"]>
+    | undefined;
+
+  function setTransport(nextTransport: RPCTransport) {
+    transport.unregisterHandler?.();
+    transport = nextTransport;
+    transport.registerHandler?.(handlePacket);
+  }
+
+  function setRequestHandler(handler: RPCRequestHandler<Schema["requests"]>) {
+    if (typeof handler === "function") {
+      requestHandler = handler as RPCRequestHandlerFn<Schema["requests"]>;
+      return;
+    }
+
+    requestHandler = (method, params) => {
+      const requestHandlerObject = handler as RPCRequestHandlerObject<Schema["requests"]>;
+      const specificHandler = requestHandlerObject[method];
+      if (specificHandler) {
+        return (specificHandler as (...args: [unknown]) => unknown)(params);
+      }
+      if (!requestHandlerObject._) {
+        throw new Error(`The requested method has no handler: ${String(method)}`);
+      }
+      return requestHandlerObject._(method, params as never);
+    };
+  }
+
+  if (options.transport) {
+    setTransport(options.transport);
+  }
+  if (options.requestHandler) {
+    setRequestHandler(options.requestHandler);
+  }
+
+  let lastRequestId = 0;
+  const maxRequestTime = options.maxRequestTime ?? DEFAULT_MAX_REQUEST_TIME;
+  const pendingRequests = new Map<
+    number,
+    {
+      resolve: (value: unknown) => void;
+      reject: (error: Error) => void;
+      timeout: ReturnType<typeof setTimeout>;
+    }
+  >();
+  const messageListeners = new Map<string, Set<(payload: unknown) => void>>();
+  const wildcardListeners = new Set<(messageName: string, payload: unknown) => void>();
+
+  function nextRequestId() {
+    if (lastRequestId < MAX_ID) {
+      lastRequestId += 1;
+      return lastRequestId;
+    }
+    lastRequestId = 1;
+    return lastRequestId;
+  }
+
+  function request<M extends keyof RemoteSchema["requests"]>(
+    method: M,
+    ...args: undefined extends RemoteSchema["requests"][M]["params"]
+      ? [params?: RemoteSchema["requests"][M]["params"]]
+      : [params: RemoteSchema["requests"][M]["params"]]
+  ): Promise<RemoteSchema["requests"][M]["response"]> {
+    if (!transport.send) {
+      throw missingTransportMethodError(["send"], "issue requests");
+    }
+
+    const id = nextRequestId();
+    const params = args[0];
+    const packet: RPCRequestPacket = {
+      type: "request",
+      id,
+      method: String(method),
+      params
+    };
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new Error(`Request timed out: ${String(method)}`));
+      }, maxRequestTime);
+
+      pendingRequests.set(id, { resolve, reject, timeout });
+      transport.send?.(packet);
+    }) as Promise<RemoteSchema["requests"][M]["response"]>;
+  }
+
+  function send<M extends keyof RemoteSchema["messages"]>(
+    messageName: M,
+    ...args: void extends RemoteSchema["messages"][M]
+      ? []
+      : undefined extends RemoteSchema["messages"][M]
+        ? [payload?: RemoteSchema["messages"][M]]
+        : [payload: RemoteSchema["messages"][M]]
+  ): void {
+    if (!transport.send) {
+      throw missingTransportMethodError(["send"], "send messages");
+    }
+
+    transport.send({
+      type: "message",
+      id: String(messageName),
+      payload: args[0]
+    });
+  }
+
+  function addMessageListener(
+    messageName: "*" | keyof Schema["messages"],
+    listener:
+      | ((name: string, payload: unknown) => void)
+      | ((payload: unknown) => void)
+  ) {
+    if (messageName === "*") {
+      wildcardListeners.add(listener as (name: string, payload: unknown) => void);
+      return;
+    }
+
+    const key = String(messageName);
+    if (!messageListeners.has(key)) {
+      messageListeners.set(key, new Set());
+    }
+    messageListeners.get(key)?.add(listener as (payload: unknown) => void);
+  }
+
+  function removeMessageListener(
+    messageName: "*" | keyof Schema["messages"],
+    listener: ((payload: unknown) => void) | ((name: string, payload: unknown) => void)
+  ) {
+    if (messageName === "*") {
+      wildcardListeners.delete(listener as (name: string, payload: unknown) => void);
+      return;
+    }
+
+    messageListeners.get(String(messageName))?.delete(listener as (payload: unknown) => void);
+  }
+
+  async function handlePacket(packet: RPCPacket) {
+    if (packet.type === "request") {
+      if (!transport.send || !requestHandler) {
+        throw missingTransportMethodError(["send", "requestHandler"], "handle requests");
+      }
+
+      try {
+        const payload = await requestHandler(packet.method as never, packet.params as never);
+        transport.send({
+          type: "response",
+          id: packet.id,
+          success: true,
+          payload
+        });
+      } catch (error) {
+        transport.send({
+          type: "response",
+          id: packet.id,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      return;
+    }
+
+    if (packet.type === "response") {
+      const pending = pendingRequests.get(packet.id);
+      if (!pending) {
+        return;
+      }
+
+      clearTimeout(pending.timeout);
+      pendingRequests.delete(packet.id);
+
+      if (!packet.success) {
+        pending.reject(new Error(packet.error ?? "Unknown RPC error"));
+      } else {
+        pending.resolve(packet.payload);
+      }
+      return;
+    }
+
+    if (packet.type === "message") {
+      for (const listener of wildcardListeners) {
+        listener(packet.id, packet.payload);
+      }
+      for (const listener of messageListeners.get(packet.id) ?? []) {
+        listener(packet.payload);
+      }
+    }
+  }
+
+  const requestProxy = new Proxy(
+    {},
+    {
+      get(_target, method) {
+        return (params: unknown) =>
+          request(method as keyof RemoteSchema["requests"], params as never);
+      }
+    }
+  ) as {
+    [M in keyof RemoteSchema["requests"]]: (
+      ...args: undefined extends RemoteSchema["requests"][M]["params"]
+        ? [params?: RemoteSchema["requests"][M]["params"]]
+        : [params: RemoteSchema["requests"][M]["params"]]
+    ) => Promise<RemoteSchema["requests"][M]["response"]>;
+  };
+
+  const sendProxy = new Proxy(
+    {},
+    {
+      get(_target, method) {
+        return (...args: unknown[]) =>
+          (send as any)(method as keyof RemoteSchema["messages"], ...args);
+      }
+    }
+  ) as {
+    [M in keyof RemoteSchema["messages"]]: (
+      ...args: void extends RemoteSchema["messages"][M]
+        ? []
+        : undefined extends RemoteSchema["messages"][M]
+          ? [payload?: RemoteSchema["messages"][M]]
+          : [payload: RemoteSchema["messages"][M]]
+    ) => void;
+  };
+
+  return {
+    setTransport,
+    setRequestHandler,
+    request,
+    send,
+    requestProxy,
+    sendProxy,
+    addMessageListener,
+    removeMessageListener,
+    proxy: {
+      request: requestProxy,
+      send: sendProxy
+    }
+  };
+}
+
+export function defineBuniteRPC<
+  Schema extends BuniteRPCSchema,
+  Side extends "bun" | "webview"
+>(
+  side: Side,
+  config: BuniteRPCConfig<Schema, Side> & {
+    extraRequestHandlers?: Record<string, (...args: any[]) => unknown>;
+  }
+) {
+  type RemoteSide = Side extends "bun" ? "webview" : "bun";
+  type LocalSchema = {
+    requests: Schema[Side]["requests"];
+    messages: Schema[RemoteSide]["messages"];
+  };
+  type RemoteSchema = {
+    requests: Schema[RemoteSide]["requests"];
+    messages: Schema[Side]["messages"];
+  };
+
+  const rpc = createRPC<LocalSchema, RemoteSchema>({
+    maxRequestTime: config.maxRequestTime,
+    requestHandler: {
+      ...(config.handlers.requests ?? {}),
+      ...(config.extraRequestHandlers ?? {})
+    } as RPCRequestHandler<LocalSchema["requests"]>,
+    transport: {
+      registerHandler: () => {}
+    }
+  });
+
+  if (config.handlers.messages) {
+    rpc.addMessageListener("*", (messageName, payload) => {
+      const wildcardHandler = config.handlers.messages?.["*"];
+      wildcardHandler?.(messageName as never, payload as never);
+
+      const specificHandler = config.handlers.messages?.[
+        messageName as keyof Schema[Side]["messages"]
+      ];
+      if (specificHandler) {
+        (specificHandler as (payload: unknown) => void)(payload);
+      }
+    });
+  }
+
+  return rpc;
+}

package/src/shared/rpcWire.ts

@@ -0,0 +1,54 @@
+import { pack, unpack } from "msgpackr";
+import type { RPCPacket } from "./rpc";
+import {
+  RPC_AUTH_TAG_LENGTH,
+  RPC_FRAME_VERSION,
+  RPC_IV_LENGTH
+} from "./rpcWireConstants";
+
+export function encodeRPCPacket(packet: RPCPacket): Uint8Array {
+  return pack(packet) as Uint8Array;
+}
+
+export function decodeRPCPacket(data: Uint8Array): RPCPacket {
+  return unpack(data) as RPCPacket;
+}
+
+export function createEncryptedRPCFrame(
+  iv: Uint8Array,
+  encryptedPayload: Uint8Array
+): Uint8Array {
+  if (iv.byteLength !== RPC_IV_LENGTH) {
+    throw new Error(`Invalid RPC IV length: expected ${RPC_IV_LENGTH}, got ${iv.byteLength}`);
+  }
+
+  const frame = new Uint8Array(1 + RPC_IV_LENGTH + encryptedPayload.byteLength);
+  frame[0] = RPC_FRAME_VERSION;
+  frame.set(iv, 1);
+  frame.set(encryptedPayload, 1 + RPC_IV_LENGTH);
+  return frame;
+}
+
+export function parseEncryptedRPCFrame(frame: Uint8Array) {
+  if (frame.byteLength < 1 + RPC_IV_LENGTH + RPC_AUTH_TAG_LENGTH) {
+    throw new Error("Invalid RPC frame: payload is too short.");
+  }
+  if (frame[0] !== RPC_FRAME_VERSION) {
+    throw new Error(`Unsupported RPC frame version: ${frame[0]}`);
+  }
+
+  return {
+    iv: frame.subarray(1, 1 + RPC_IV_LENGTH),
+    encryptedPayload: frame.subarray(1 + RPC_IV_LENGTH)
+  };
+}
+
+export function asUint8Array(data: ArrayBuffer | ArrayBufferView | Uint8Array): Uint8Array {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return new Uint8Array(data);
+}

package/src/shared/rpcWireConstants.ts

@@ -0,0 +1,3 @@
+export const RPC_FRAME_VERSION = 1;
+export const RPC_IV_LENGTH = 12;
+export const RPC_AUTH_TAG_LENGTH = 16;

package/src/types/config.ts

@@ -0,0 +1,29 @@
+export interface BuniteConfig {
+  app: {
+    name: string;
+    identifier: string;
+    version: string;
+    description?: string;
+  };
+  build?: {
+    bun?: {
+      entrypoint?: string;
+    } & Omit<Parameters<typeof Bun.build>[0], "entrypoints" | "outdir" | "target">;
+    views?: Record<
+      string,
+      {
+        entrypoint: string;
+      } & Omit<Parameters<typeof Bun.build>[0], "entrypoints" | "outdir" | "target">
+    >;
+    copy?: Record<string, string>;
+    buildFolder?: string;
+    artifactFolder?: string;
+    targets?: string[];
+    cefVersion?: string;
+    watch?: string[];
+  };
+  runtime?: {
+    exitOnLastWindowClosed?: boolean;
+    hideConsole?: boolean;
+  };
+}

package/src/view/index.ts

@@ -0,0 +1,159 @@
+import {
+  defineBuniteRPC,
+  type BuniteRPCConfig,
+  type RPCPacket,
+  type BuniteRPCSchema,
+  type RPCSchema,
+  type RPCTransport,
+  type RPCWithTransport
+} from "../shared/rpc";
+import { decodeRPCPacket, encodeRPCPacket } from "../shared/rpcWire";
+
+type BuniteWindowGlobals = Window &
+  typeof globalThis & {
+    __buniteWebviewId?: number;
+    __buniteRpcSocketPort?: number;
+    __bunite?: {
+      receiveMessageFromBun?: (message: unknown) => void;
+    };
+    __bunite_encrypt?: (data: Uint8Array) => Promise<Uint8Array>;
+    __bunite_decrypt?: (data: Uint8Array) => Promise<Uint8Array>;
+  };
+
+const buniteWindow = window as BuniteWindowGlobals;
+const WEBVIEW_ID = buniteWindow.__buniteWebviewId;
+const RPC_SOCKET_PORT = buniteWindow.__buniteRpcSocketPort;
+
+function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+
+export class BuniteView<T extends RPCWithTransport> {
+  bunSocket?: WebSocket;
+  rpc?: T;
+  rpcHandler?: (message: unknown) => void;
+
+  constructor(config: { rpc: T }) {
+    this.rpc = config.rpc;
+    this.init();
+  }
+
+  init() {
+    this.initSocketToBun();
+    buniteWindow.__bunite ??= {};
+    buniteWindow.__bunite.receiveMessageFromBun = this.receiveMessageFromBun.bind(this);
+    this.rpc?.setTransport(this.createTransport());
+  }
+
+  initSocketToBun() {
+    if (WEBVIEW_ID == null || RPC_SOCKET_PORT == null) {
+      console.warn("[bunite] Preload globals are missing. BuniteView will stay disconnected until native preload wiring is implemented.");
+      return;
+    }
+
+    // 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}`
+      );
+      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;
+      }
+
+      try {
+        const decrypt = buniteWindow.__bunite_decrypt;
+        if (!decrypt) {
+          console.error("[bunite] 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.rpcHandler?.(packet);
+      } catch (error) {
+        console.error("[bunite] Failed to parse message from Bun", error);
+      }
+    });
+  }
+
+  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;
+    }
+    return null;
+  }
+
+  createTransport(): RPCTransport {
+    return {
+      send: (message) => {
+        if (this.bunSocket?.readyState === WebSocket.OPEN) {
+          void this.bunBridge(message).catch((error) => {
+            console.error("[bunite] Failed to send RPC packet", error);
+          });
+        }
+      },
+      registerHandler: (handler: (packet: any) => void) => {
+        this.rpcHandler = handler;
+      },
+      unregisterHandler: () => {
+        this.rpcHandler = undefined;
+      }
+    };
+  }
+
+  receiveMessageFromBun(message: unknown) {
+    this.rpcHandler?.(message);
+  }
+
+  async bunBridge(message: RPCPacket) {
+    if (this.bunSocket?.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    const encrypt = buniteWindow.__bunite_encrypt;
+    if (!encrypt) {
+      console.error("[bunite] No encrypt function available in preload globals");
+      return;
+    }
+
+    const encrypted = await encrypt(encodeRPCPacket(message));
+    this.bunSocket.send(toArrayBuffer(encrypted));
+  }
+
+  static defineRPC<Schema extends BuniteRPCSchema>(
+    config: BuniteRPCConfig<Schema, "webview">
+  ) {
+    return defineBuniteRPC("webview", config);
+  }
+}
+
+export type {
+  BuniteRPCConfig,
+  BuniteRPCSchema,
+  RPCSchema
+};