bunite-core 0.8.1 → 0.10.0

package/src/preload/tsconfig.json

@@ -1,14 +1,7 @@
 {
+  "extends": "../../../tsconfig.base.json",
   "compilerOptions": {
-    "composite": true,
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "bundler",
-    "lib": ["ES2022", "DOM"],
-    "strict": true,
-    "exactOptionalPropertyTypes": false,
-    "skipLibCheck": true,
-    "noEmit": true
+    "composite": true
   },
-  "include": ["runtime.ts", "webviewElement.ts"]
+  "include": ["runtime.ts", "../webview/native.ts", "../rpc/**/*.ts"]
 }

package/src/rpc/encrypt.ts

@@ -0,0 +1,74 @@
+import type { BytesPipe } from "./transport";
+
+const VERSION = 1;
+const IV_LENGTH = 12;
+const HEADER_LENGTH = 1 + IV_LENGTH;
+
+function toBufferSource(view: Uint8Array): ArrayBuffer {
+  const out = new ArrayBuffer(view.byteLength);
+  new Uint8Array(out).set(view);
+  return out;
+}
+
+async function importAesGcmKey(rawKey: Uint8Array): Promise<CryptoKey> {
+  return crypto.subtle.importKey("raw", toBufferSource(rawKey), "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+
+// WebCrypto AES-256-GCM (browser / preload). For Bun-side use `host/encryptedPipe.ts` (node:crypto).
+export async function createEncryptedPipe(base: BytesPipe, rawKey: Uint8Array): Promise<BytesPipe> {
+  const key = await importAesGcmKey(rawKey);
+  let downstream: ((bytes: Uint8Array) => void) | undefined;
+  let sendChain: Promise<void> = Promise.resolve();
+  let recvChain: Promise<void> = Promise.resolve();
+  let closed = false;
+  const closeOnce = () => { if (!closed) { closed = true; base.close(); } };
+
+  base.setReceive((frame) => {
+    if (closed) return;
+    if (frame.length < HEADER_LENGTH || frame[0] !== VERSION) {
+      closeOnce();
+      return;
+    }
+    const iv = toBufferSource(frame.subarray(1, HEADER_LENGTH));
+    const payload = toBufferSource(frame.subarray(HEADER_LENGTH));
+    recvChain = recvChain.then(async () => {
+      if (closed) return;
+      try {
+        const buf = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, payload);
+        downstream?.(new Uint8Array(buf));
+      } catch {
+        closeOnce();
+      }
+    });
+  });
+
+  return {
+    send(bytes) {
+      if (closed) return;
+      const payload = toBufferSource(bytes);
+      sendChain = sendChain.then(async () => {
+        if (closed) return;
+        try {
+          const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+          const ivBuf = toBufferSource(iv);
+          const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv: ivBuf }, key, payload);
+          const encArr = new Uint8Array(encrypted);
+          const out = new Uint8Array(HEADER_LENGTH + encArr.byteLength);
+          out[0] = VERSION;
+          out.set(iv, 1);
+          out.set(encArr, HEADER_LENGTH);
+          base.send(out);
+        } catch {
+          closeOnce();
+        }
+      });
+    },
+    setReceive(handler) {
+      downstream = handler;
+    },
+    close() {
+      closeOnce();
+    },
+  };
+}
+

package/src/rpc/error.ts

@@ -0,0 +1,68 @@
+export type IpcCode =
+  | "not_found"
+  | "failed_precondition"
+  | "already_exists"
+  | "invalid_argument"
+  | "cancelled"
+  | "deadline_exceeded"
+  | "resource_exhausted"
+  | "unavailable"
+  | "internal";
+
+export type FailedPreconditionReason =
+  | "version_mismatch"
+  | "unauthorized"
+  | "unregistered_cap_return"
+  | "revoked";
+
+export type ResourceExhaustedReason =
+  | "max_frame_bytes"
+  | "max_concurrent_calls"
+  | "max_caps_per_connection"
+  | "stream_credit_window"
+  | "rate_limited";
+
+export type UnavailableReason =
+  | "peer_closing"
+  | "goaway"
+  | "plugin_unloading";
+
+export type AlreadyExistsReason =
+  | "name_collision"
+  | "reserved_namespace";
+
+export type RetrySpec =
+  | { kind: "never" }
+  | { kind: "transparent" }
+  | { kind: "after-cooldown"; minMs: number }
+  | { kind: "after-resync" };
+
+export interface IpcStatus {
+  code: IpcCode;
+  message?: string;
+  details?: unknown;
+  retry?: RetrySpec;
+}
+
+export class IpcError extends Error {
+  readonly code: IpcCode;
+  readonly details: unknown;
+  readonly retry?: RetrySpec;
+
+  constructor(status: IpcStatus) {
+    super(status.message ?? status.code);
+    this.name = "IpcError";
+    this.code = status.code;
+    this.details = status.details;
+    this.retry = status.retry;
+  }
+
+  toStatus(): IpcStatus {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details,
+      retry: this.retry,
+    };
+  }
+}

package/src/rpc/framework.ts

@@ -0,0 +1,132 @@
+import { call, defineCap, stream, cap } from "./schema";
+import type { CapDef } from "./schema";
+
+export const BrowserWindowCap = defineCap("bunite.BrowserWindow", {
+  focus: call<void, void>(),
+  close: call<void, void>(),
+  setBounds: call<{ x: number; y: number; w: number; h: number }, void>(),
+  setTitle: call<{ title: string }, void>(),
+  id: call<void, number>({ idempotent: true }),
+  label: call<void, string>({ idempotent: true }),
+});
+
+export const WindowCap = defineCap("bunite.Window", {
+  create: call<WindowCreateOpts, typeof BrowserWindowCap>({ returns: cap(BrowserWindowCap) }),
+  list: call<void, typeof BrowserWindowCap>({ returns: cap.array(BrowserWindowCap), idempotent: true }),
+  focus: call<{ id?: number; label?: string }, void>(),
+  close: call<{ id?: number; label?: string }, void>(),
+});
+
+export interface WindowCreateOpts {
+  url: string;
+  title?: string;
+  bounds?: { x?: number; y?: number; w?: number; h?: number };
+  label?: string;
+}
+
+export const FileRefCap = defineCap("bunite.FileRef", {
+  text: call<void, string>({ idempotent: true }),
+  bytes: call<void, Uint8Array>({ idempotent: true }),
+  path: call<void, string>({ idempotent: true }),
+  revoke: call<void, void>(),
+}, { disposal: { method: "revoke" } });
+
+export const DialogsCap = defineCap("bunite.Dialogs", {
+  openFile: call<DialogOpenFileOpts, typeof FileRefCap>({ returns: cap.array(FileRefCap) }),
+  saveFile: call<DialogSaveFileOpts, typeof FileRefCap>({ returns: cap(FileRefCap) }),
+  showMessage: call<DialogMessageOpts, "primary" | "secondary" | "tertiary">(),
+});
+
+export interface DialogOpenFileOpts {
+  title?: string;
+  filters?: { name: string; extensions: string[] }[];
+  multiple?: boolean;
+  startDir?: string;
+}
+
+export interface DialogSaveFileOpts {
+  title?: string;
+  defaultName?: string;
+  filters?: { name: string; extensions: string[] }[];
+}
+
+export interface DialogMessageOpts {
+  title?: string;
+  body: string;
+  primary?: string;
+  secondary?: string;
+  tertiary?: string;
+}
+
+export const ClipboardCap = defineCap("bunite.Clipboard", {
+  readText: call<void, string>({ idempotent: true }),
+  writeText: call<{ text: string }, void>(),
+  readBytes: call<{ mime: string }, Uint8Array>({ idempotent: true }),
+  writeBytes: call<{ mime: string; data: Uint8Array }, void>(),
+});
+
+export const ShellCap = defineCap("bunite.Shell", {
+  openExternal: call<{ url: string }, boolean>(),
+  showItemInFolder: call<{ path: string }, void>(),
+});
+
+export type SurfaceMask = { x: number; y: number; w: number; h: number };
+
+export const SurfaceCap = defineCap("bunite.Surface", {
+  init: call<{
+    src: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    hidden?: boolean;
+  }, { surfaceId: number }>(),
+  resize: call<{ surfaceId: number; x: number; y: number; w: number; h: number }, void>(),
+  remove: call<{ surfaceId: number }, void>(),
+  setHidden: call<{ surfaceId: number; hidden: boolean }, void>(),
+  setMasks: call<{ surfaceId: number; masks: SurfaceMask[] }, void>(),
+  setAllPassthrough: call<{ passthrough: boolean }, void>(),
+  bringAllVisiblesToFront: call<void, void>(),
+  navigate: call<{ surfaceId: number; url: string }, void>(),
+  goBack: call<{ surfaceId: number }, void>(),
+  reload: call<{ surfaceId: number }, void>(),
+  didNavigate: stream<void, { surfaceId: number; url: string }>(),
+});
+
+export const RuntimeCap = defineCap("bunite.Runtime", {
+  window: call<void, typeof WindowCap>({ returns: cap(WindowCap), idempotent: true }),
+  dialogs: call<void, typeof DialogsCap>({ returns: cap(DialogsCap), idempotent: true }),
+  clipboard: call<void, typeof ClipboardCap>({ returns: cap(ClipboardCap), idempotent: true }),
+  shell: call<void, typeof ShellCap>({ returns: cap(ShellCap), idempotent: true }),
+  appName: call<void, string>({ idempotent: true }),
+  appVersion: call<void, string>({ idempotent: true }),
+  theme: call<void, "light" | "dark">({ idempotent: true }),
+  themeWatch: stream<void, "light" | "dark">(),
+  surface: call<void, typeof SurfaceCap>({ returns: cap(SurfaceCap), idempotent: true }),
+});
+
+export const FRAMEWORK_TYPE_IDS = {
+  Runtime: 1,
+  Window: 2,
+  Dialogs: 3,
+  FileRef: 4,
+  Clipboard: 5,
+  Shell: 6,
+  BrowserWindow: 7,
+  Surface: 8,
+} as const;
+
+const FRAMEWORK_CAP_TYPE_IDS = new Map<CapDef<any, any>, number>([
+  [RuntimeCap, FRAMEWORK_TYPE_IDS.Runtime],
+  [WindowCap, FRAMEWORK_TYPE_IDS.Window],
+  [DialogsCap, FRAMEWORK_TYPE_IDS.Dialogs],
+  [FileRefCap, FRAMEWORK_TYPE_IDS.FileRef],
+  [ClipboardCap, FRAMEWORK_TYPE_IDS.Clipboard],
+  [ShellCap, FRAMEWORK_TYPE_IDS.Shell],
+  [BrowserWindowCap, FRAMEWORK_TYPE_IDS.BrowserWindow],
+  [SurfaceCap, FRAMEWORK_TYPE_IDS.Surface],
+]);
+
+export function frameworkTypeIdOf(cap: CapDef<any, any>): number | undefined {
+  return FRAMEWORK_CAP_TYPE_IDS.get(cap);
+}

package/src/rpc/index.ts

@@ -0,0 +1,138 @@
+export {
+  call,
+  stream,
+  cap,
+  defineCap,
+  defineSchema,
+  isCallDef,
+  isStreamDef,
+  isCapDef,
+  isSchema,
+  isCapRef,
+  isCapArray,
+  isCapRecord,
+  returnsKindOf,
+} from "./schema";
+
+export type {
+  CallDef,
+  StreamDef,
+  CapDef,
+  CapRefToken,
+  CapArrayToken,
+  CapRecordToken,
+  AnyCapToken,
+  MethodDef,
+  MethodsRecord,
+  DisposalSpec,
+  DefineCapOpts,
+  Schema,
+  SchemaRoots,
+  ImplsOf,
+  ReturnsKind,
+  CallCtx,
+  Attestation,
+  ExportedCap,
+  ClientOf,
+  ImplOf,
+  ClientReturn,
+} from "./schema";
+
+export {
+  CapRef,
+  CAP_REF_EXT,
+  createCodec,
+  isFrame,
+  DEFAULT_MAX_BYTES,
+  PROTOCOL_VERSION,
+  FRAMEWORK_NAME_PREFIX,
+  BOOTSTRAP_METHOD,
+} from "./wire";
+
+export type {
+  Frame,
+  CallFrame,
+  ResultFrame,
+  StreamFrame,
+  CancelFrame,
+  DropFrame,
+  HelloFrame,
+  GoAwayFrame,
+  CapRevokedFrame,
+  StreamEvent,
+  Target,
+  CallMeta,
+  CodecPair,
+  u32,
+  u53,
+} from "./wire";
+
+export { IpcError } from "./error";
+
+export type {
+  IpcCode,
+  IpcStatus,
+  RetrySpec,
+  FailedPreconditionReason,
+  ResourceExhaustedReason,
+  UnavailableReason,
+  AlreadyExistsReason,
+} from "./error";
+
+export {
+  CapTable,
+  USER_ROOTS_CAP_ID,
+  RUNTIME_CAP_ID,
+  USER_ROOTS_TYPE_ID,
+  RUNTIME_TYPE_ID,
+  FIRST_USER_CAP_ID,
+  FIRST_USER_TYPE_ID,
+  MAX_CAPS_PER_CONNECTION,
+  MAX_IN_FLIGHT_CALLS_PER_CONNECTION,
+  createConnection,
+} from "./peer";
+
+export {
+  RuntimeCap,
+  WindowCap,
+  BrowserWindowCap,
+  DialogsCap,
+  FileRefCap,
+  ClipboardCap,
+  ShellCap,
+  SurfaceCap,
+  FRAMEWORK_TYPE_IDS,
+} from "./framework";
+
+export type {
+  WindowCreateOpts,
+  DialogOpenFileOpts,
+  DialogSaveFileOpts,
+  DialogMessageOpts,
+} from "./framework";
+
+export type {
+  Transport,
+  Connection,
+  ConnectionOptions,
+  ConnectionEvents,
+  CapTableEntry,
+  PendingCall,
+  Policy,
+  IfExists,
+  ServeHandle,
+} from "./peer";
+
+export {
+  createFrameTransport,
+  createWebSocketPipe,
+} from "./transport";
+
+export type {
+  BytesPipe,
+  WebSocketLike,
+} from "./transport";
+
+export { createEncryptedPipe } from "./encrypt";
+
+export { Stream } from "./stream";