bunite-core 0.0.1

package/src/bun/index.ts

@@ -0,0 +1,41 @@
+import { app } 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";
+import {
+  createRPC,
+  defineBuniteRPC,
+  type BuniteRPCConfig,
+  type BuniteRPCSchema,
+  type RPCSchema,
+  type RPCWithTransport
+} from "../shared/rpc";
+import type { BuniteConfig } from "../types/config";
+import type { MessageBoxOptions, MessageBoxResponse } from "./core/Utils";
+
+export {
+  app,
+  BrowserWindow,
+  BrowserView,
+  Utils,
+  buniteEventEmitter,
+  completePermissionRequest,
+  createRPC,
+  defineBuniteRPC
+};
+
+export type {
+  BuniteEvent,
+  BuniteConfig,
+  BuniteRPCConfig,
+  BuniteRPCSchema,
+  BrowserViewOptions,
+  MessageBoxOptions,
+  MessageBoxResponse,
+  RPCSchema,
+  RPCWithTransport,
+  WindowOptionsType
+};

package/src/bun/preload/index.ts

@@ -0,0 +1,73 @@
+import { RPC_FRAME_VERSION, RPC_IV_LENGTH } from "../../shared/rpcWireConstants";
+
+type BunitePreloadWindow = Window &
+  typeof globalThis & {
+    __bunite?: {
+      receiveMessageFromBun?: (message: unknown) => void;
+    };
+    __buniteWebviewId?: number;
+    __buniteRpcSocketPort?: number;
+    __bunite_encrypt?: (data: Uint8Array) => Promise<Uint8Array>;
+    __bunite_decrypt?: (data: Uint8Array) => Promise<Uint8Array>;
+  };
+
+function base64ToUint8Array(base64: string) {
+  return Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
+}
+
+function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy.buffer;
+}
+
+async function importAesKey(secretKeyBase64: string) {
+  const keyData = base64ToUint8Array(secretKeyBase64);
+  return crypto.subtle.importKey("raw", toArrayBuffer(keyData), "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+
+export async function installBunitePreloadGlobals(options: {
+  webviewId: number;
+  rpcSocketPort: number;
+  secretKeyBase64: string;
+}) {
+  const buniteWindow = window as BunitePreloadWindow;
+  const cryptoKey = await importAesKey(options.secretKeyBase64);
+
+  const encrypt = async (data: Uint8Array) => {
+    const iv = crypto.getRandomValues(new Uint8Array(RPC_IV_LENGTH));
+    const encrypted = new Uint8Array(
+      await crypto.subtle.encrypt({ name: "AES-GCM", iv }, cryptoKey, toArrayBuffer(data))
+    );
+    const frame = new Uint8Array(1 + iv.length + encrypted.length);
+    frame[0] = RPC_FRAME_VERSION;
+    frame.set(iv, 1);
+    frame.set(encrypted, 1 + iv.length);
+    return frame;
+  };
+
+  const decrypt = async (frame: Uint8Array) => {
+    if (frame.length < 1 + RPC_IV_LENGTH + 16) {
+      throw new Error("Invalid bunite RPC frame.");
+    }
+    if (frame[0] !== RPC_FRAME_VERSION) {
+      throw new Error("Unsupported bunite RPC frame version.");
+    }
+    const iv = frame.slice(1, 1 + RPC_IV_LENGTH);
+    const encrypted = frame.slice(1 + RPC_IV_LENGTH);
+
+    const decrypted = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv },
+      cryptoKey,
+      toArrayBuffer(encrypted)
+    );
+
+    return new Uint8Array(decrypted);
+  };
+
+  buniteWindow.__bunite ??= {};
+  buniteWindow.__buniteWebviewId = options.webviewId;
+  buniteWindow.__buniteRpcSocketPort = options.rpcSocketPort;
+  buniteWindow.__bunite_encrypt = encrypt;
+  buniteWindow.__bunite_decrypt = decrypt;
+}

package/src/bun/preload/inline.ts

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, resolve, sep } from "node:path";
+
+function escapeRootForComparison(path: string) {
+  return process.platform === "win32" ? path.toLowerCase() : path;
+}
+
+function resolveViewsFile(viewsRoot: string, url: string) {
+  const relativePath = url.replace(/^views:\/\//, "").replace(/^[\\/]+/, "");
+  const normalizedRoot = resolve(viewsRoot);
+  const candidate = resolve(normalizedRoot, relativePath.split("/").join(sep));
+  const comparableRoot = escapeRootForComparison(normalizedRoot);
+  const comparableCandidate = escapeRootForComparison(candidate);
+
+  if (
+    comparableCandidate !== comparableRoot &&
+    !comparableCandidate.startsWith(`${comparableRoot}${sep}`)
+  ) {
+    throw new Error(`preload path escapes viewsRoot: ${url}`);
+  }
+
+  return candidate;
+}
+
+function readCustomPreload(preload: string | null, viewsRoot: string | null) {
+  if (!preload) {
+    return "";
+  }
+
+  try {
+    const resolvedPath = preload.startsWith("views://")
+      ? viewsRoot
+        ? resolveViewsFile(viewsRoot, preload)
+        : null
+      : isAbsolute(preload)
+        ? preload
+        : resolve(preload);
+
+    if (!resolvedPath) {
+      console.warn(`[bunite] Cannot resolve preload without viewsRoot: ${preload}`);
+      return "";
+    }
+    if (!existsSync(resolvedPath)) {
+      console.warn(`[bunite] Preload file was not found: ${resolvedPath}`);
+      return "";
+    }
+
+    return readFileSync(resolvedPath, "utf8");
+  } catch (error) {
+    console.warn("[bunite] Failed to resolve preload script.", error);
+    return "";
+  }
+}
+
+// Pre-built preload runtime (built via `bun run build:preload` in package/)
+const runtimePath = resolve(import.meta.dirname, "../../preload/runtime.built.js");
+let cachedRuntime: string | null = null;
+
+function getPreloadRuntime(): string {
+  if (cachedRuntime === null) {
+    if (!existsSync(runtimePath)) {
+      throw new Error(
+        `Preload runtime not found at ${runtimePath}. Run "bun run build:preload" in the package directory.`
+      );
+    }
+    cachedRuntime = readFileSync(runtimePath, "utf8");
+  }
+  return cachedRuntime;
+}
+
+export function buildViewPreloadScript(options: {
+  preload: string | null;
+  viewsRoot: string | null;
+  webviewId: number;
+  rpcSocketPort: number;
+  secretKey: Uint8Array;
+}) {
+  const secretKeyBase64 = Buffer.from(options.secretKey).toString("base64");
+
+  // Per-view config — these globals are consumed by the pre-built runtime
+  const config = `var __buniteWebviewId=${options.webviewId},__buniteRpcSocketPort=${options.rpcSocketPort},__buniteSecretKeyBase64=${JSON.stringify(secretKeyBase64)};`;
+
+  const runtime = getPreloadRuntime();
+  const customPreload = readCustomPreload(options.preload, options.viewsRoot).trim();
+
+  return [config, runtime, customPreload].filter(Boolean).join("\n");
+}