gloomberb 0.5.1 → 0.6.0

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -0,0 +1,173 @@
+/// <reference lib="dom" />
+import { Electroview } from "electrobun/view";
+import { measurePerfAsync } from "../../../utils/perf-marks";
+import {
+  type ApplicationMenuSelectMessage,
+  type CapabilityEventMessage,
+  type ContextMenuSelectMessage,
+  type DesktopDockPreviewMessage,
+  type DesktopStateMessage,
+  type ElectrobunBackendInit,
+  type ElectrobunDesktopRpcSchema,
+  type UpdateProgressMessage,
+} from "../shared/protocol";
+import { decodeRpcValue, encodeRpcValue } from "./rpc-codec";
+
+type ContextMenuSelectListener = (message: ContextMenuSelectMessage) => void;
+type ApplicationMenuSelectListener = (message: ApplicationMenuSelectMessage) => void;
+type DesktopStateListener = (message: DesktopStateMessage) => void;
+type DesktopDockPreviewListener = (message: DesktopDockPreviewMessage) => void;
+type UpdateProgressListener = (message: UpdateProgressMessage) => void;
+type CapabilityEventListener = (message: CapabilityEventMessage) => void;
+
+let initSnapshot: ElectrobunBackendInit | null = null;
+const contextMenuSelectListeners = new Map<string, Set<ContextMenuSelectListener>>();
+const applicationMenuSelectListeners = new Set<ApplicationMenuSelectListener>();
+const desktopStateListeners = new Set<DesktopStateListener>();
+const desktopDockPreviewListeners = new Set<DesktopDockPreviewListener>();
+const updateProgressListeners = new Set<UpdateProgressListener>();
+const capabilityEventListeners = new Map<string, Set<CapabilityEventListener>>();
+
+function dispatch<T>(
+  listeners: Map<string, Set<(value: T) => void>>,
+  key: string,
+  value: T,
+): void {
+  for (const listener of listeners.get(key) ?? []) {
+    listener(value);
+  }
+}
+
+function subscribe<T>(
+  listeners: Map<string, Set<(value: T) => void>>,
+  key: string,
+  listener: (value: T) => void,
+): () => void {
+  if (!listeners.has(key)) {
+    listeners.set(key, new Set());
+  }
+  listeners.get(key)!.add(listener);
+  return () => {
+    const bucket = listeners.get(key);
+    if (!bucket) return;
+    bucket.delete(listener);
+    if (bucket.size === 0) {
+      listeners.delete(key);
+    }
+  };
+}
+
+const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
+  maxRequestTime: 120_000,
+  handlers: {
+    requests: {},
+    messages: {
+      "context-menu.select": (message) => {
+        dispatch(contextMenuSelectListeners, message.requestId, message);
+      },
+      "application-menu.select": (message) => {
+        const decoded = { command: decodeRpcValue<ApplicationMenuSelectMessage["command"]>(message.command) };
+        for (const listener of applicationMenuSelectListeners) {
+          listener(decoded);
+        }
+      },
+      "desktop.state": (message) => {
+        for (const listener of desktopStateListeners) {
+          listener({ snapshot: decodeRpcValue(message.snapshot) });
+        }
+      },
+      "desktop.dockPreview": (message) => {
+        for (const listener of desktopDockPreviewListeners) {
+          listener({ preview: decodeRpcValue(message.preview) });
+        }
+      },
+      "update.progress": (message) => {
+        const decoded = { progress: decodeRpcValue<UpdateProgressMessage["progress"]>(message.progress) };
+        for (const listener of updateProgressListeners) {
+          listener(decoded);
+        }
+      },
+      "capability.event": (message) => {
+        dispatch(capabilityEventListeners, message.subscriptionId, {
+          subscriptionId: message.subscriptionId,
+          event: decodeRpcValue(message.event),
+        });
+      },
+    },
+  },
+});
+
+const electroview = new Electroview({ rpc });
+
+async function waitForBridgeReady(): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < 5_000) {
+    if (electroview.bunSocket?.readyState === WebSocket.OPEN) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error("Electrobun RPC socket did not open in time.");
+}
+
+export async function backendRequest<T = unknown>(method: string, payload: unknown = null): Promise<T> {
+  const result = await measurePerfAsync("electrobun.rpc.request", async () => {
+    await waitForBridgeReady();
+    return rpc.request["backend.request"]({
+      method,
+      payload: encodeRpcValue(payload),
+    });
+  }, { method });
+  return decodeRpcValue<T>(result);
+}
+
+export async function initElectrobunBackend(payload?: { kind?: "main" | "detached"; paneId?: string }): Promise<ElectrobunBackendInit> {
+  initSnapshot = await backendRequest<ElectrobunBackendInit>("init", payload ?? null);
+  return initSnapshot;
+}
+
+export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null {
+  return initSnapshot;
+}
+
+export function onCapabilityEvent(
+  subscriptionId: string,
+  listener: (message: CapabilityEventMessage) => void,
+): () => void {
+  return subscribe(capabilityEventListeners, subscriptionId, listener);
+}
+
+export function onContextMenuSelect(
+  requestId: string,
+  listener: (message: ContextMenuSelectMessage) => void,
+): () => void {
+  return subscribe(contextMenuSelectListeners, requestId, listener);
+}
+
+export function onApplicationMenuSelect(listener: ApplicationMenuSelectListener): () => void {
+  applicationMenuSelectListeners.add(listener);
+  return () => {
+    applicationMenuSelectListeners.delete(listener);
+  };
+}
+
+export function onDesktopState(listener: DesktopStateListener): () => void {
+  desktopStateListeners.add(listener);
+  return () => {
+    desktopStateListeners.delete(listener);
+  };
+}
+
+export function onDesktopDockPreview(listener: DesktopDockPreviewListener): () => void {
+  desktopDockPreviewListeners.add(listener);
+  return () => {
+    desktopDockPreviewListeners.delete(listener);
+  };
+}
+
+export function onUpdateProgress(listener: UpdateProgressListener): () => void {
+  updateProgressListeners.add(listener);
+  return () => {
+    updateProgressListeners.delete(listener);
+  };
+}

package/src/renderers/electrobun/view/broker-remote-client.ts

@@ -0,0 +1,154 @@
+import {
+  setBrokerRemoteClient,
+  type BrokerRemoteClient,
+} from "../../../brokers/remote-broker-adapter";
+import {
+  BROKER_CAPABILITY_ID,
+  type BrokerQuoteEvent,
+  type BrokerRemoteEvent,
+  type BrokerStatusEvent,
+} from "../../../capabilities";
+import type { BrokerConnectionStatus } from "../../../types/broker";
+import { backendRequest, onCapabilityEvent } from "./backend-rpc";
+
+const statuses = new Map<string, BrokerConnectionStatus>();
+const statusSubscriptions = new Map<string, StatusSubscription>();
+const STATUS_SUBSCRIPTION_TEARDOWN_DELAY_MS = 250;
+let nextSubscriptionId = 1;
+
+type StatusSubscription = {
+  subscriptionId: string;
+  listeners: Set<() => void>;
+  disposeEvents: () => void;
+  teardownTimer: ReturnType<typeof setTimeout> | null;
+};
+
+function isBrokerStatusEvent(event: BrokerRemoteEvent): event is BrokerStatusEvent {
+  return event.kind === "status";
+}
+
+function isBrokerQuoteEvent(event: BrokerRemoteEvent): event is BrokerQuoteEvent {
+  return event.kind === "quote";
+}
+
+function invokeBrokerCapability<T>(operationId: string, payload: unknown): Promise<T> {
+  return backendRequest<T>("capability.invoke", {
+    capabilityId: BROKER_CAPABILITY_ID,
+    operationId,
+    payload,
+  });
+}
+
+function subscribeBrokerCapability(
+  subscriptionId: string,
+  operationId: string,
+  payload: unknown,
+): Promise<void> {
+  return backendRequest("capability.subscribe", {
+    subscriptionId,
+    capabilityId: BROKER_CAPABILITY_ID,
+    operationId,
+    payload,
+  });
+}
+
+function disposeStatusSubscription(instanceId: string, entry: StatusSubscription): void {
+  if (statusSubscriptions.get(instanceId) !== entry) return;
+  entry.disposeEvents();
+  if (entry.teardownTimer) clearTimeout(entry.teardownTimer);
+  statusSubscriptions.delete(instanceId);
+  void backendRequest("capability.unsubscribe", { subscriptionId: entry.subscriptionId }).catch(() => {});
+}
+
+function getStatusSubscription(instanceId: string): StatusSubscription {
+  const current = statusSubscriptions.get(instanceId);
+  if (current) return current;
+
+  const subscriptionId = `broker-status:${instanceId}:${nextSubscriptionId++}`;
+  const entry: StatusSubscription = {
+    subscriptionId,
+    listeners: new Set(),
+    disposeEvents: () => {},
+    teardownTimer: null,
+  };
+  entry.disposeEvents = onCapabilityEvent(subscriptionId, (message) => {
+    const event = message.event as BrokerRemoteEvent;
+    if (!isBrokerStatusEvent(event)) return;
+    statuses.set(event.instanceId, event.status);
+    for (const listener of entry.listeners) {
+      listener();
+    }
+  });
+  statusSubscriptions.set(instanceId, entry);
+
+  void subscribeBrokerCapability(subscriptionId, "status", { instanceId }).catch((error) => {
+    disposeStatusSubscription(instanceId, entry);
+    console.error("Failed to subscribe to broker status", error);
+  });
+
+  return entry;
+}
+
+const client: BrokerRemoteClient = {
+  invoke(operationInstanceId, operation, args = []) {
+    return invokeBrokerCapability("invoke", {
+      instanceId: operationInstanceId,
+      operation,
+      args,
+    });
+  },
+
+  getStatus(instanceId) {
+    return statuses.get(instanceId) ?? null;
+  },
+
+  subscribeStatus(instanceId, listener) {
+    const entry = getStatusSubscription(instanceId);
+    if (entry.teardownTimer) {
+      clearTimeout(entry.teardownTimer);
+      entry.teardownTimer = null;
+    }
+    entry.listeners.add(listener);
+    return () => {
+      entry.listeners.delete(listener);
+      if (entry.listeners.size > 0 || entry.teardownTimer) return;
+      entry.teardownTimer = setTimeout(() => {
+        entry.teardownTimer = null;
+        if (entry.listeners.size === 0) {
+          disposeStatusSubscription(instanceId, entry);
+        }
+      }, STATUS_SUBSCRIPTION_TEARDOWN_DELAY_MS);
+    };
+  },
+
+  subscribeQuotes(instanceId, targets, onQuote) {
+    const subscriptionId = `broker-quotes:${instanceId}:${nextSubscriptionId++}`;
+    const disposeEvents = onCapabilityEvent(subscriptionId, (message) => {
+      const event = message.event as BrokerRemoteEvent;
+      if (!isBrokerQuoteEvent(event)) return;
+      onQuote(event.target, event.quote);
+    });
+    void subscribeBrokerCapability(subscriptionId, "quotes", { instanceId, targets }).catch((error) => {
+      disposeEvents();
+      console.error("Failed to subscribe to broker quotes", error);
+    });
+    return () => {
+      disposeEvents();
+      void backendRequest("capability.unsubscribe", { subscriptionId }).catch(() => {});
+    };
+  },
+
+  async removeInstance(instanceId) {
+    await invokeBrokerCapability("removeInstance", { instanceId });
+    statuses.delete(instanceId);
+  },
+
+  async destroyAll() {
+    await invokeBrokerCapability("destroyAll", {});
+    statuses.clear();
+  },
+};
+
+export function installElectrobunBrokerRemoteClient(): void {
+  setBrokerRemoteClient(client);
+}

package/src/renderers/electrobun/view/config-host.ts

@@ -0,0 +1,35 @@
+import { setConfigStoreHost, type ConfigStoreHost } from "../../../data/config-store";
+import type { AppConfig } from "../../../types/config";
+import { backendRequest, getElectrobunBackendInitSnapshot } from "./backend-rpc";
+
+const electrobunConfigStoreHost: ConfigStoreHost = {
+  async getDataDir() {
+    return getElectrobunBackendInitSnapshot()?.config.dataDir ?? null;
+  },
+  async loadConfig() {
+    const config = getElectrobunBackendInitSnapshot()?.config;
+    if (!config) throw new Error("Electrobun backend has not initialized config.");
+    return config;
+  },
+  async saveConfig(config: AppConfig) {
+    await backendRequest("config.save", { config });
+  },
+  async initDataDir() {
+    const config = getElectrobunBackendInitSnapshot()?.config;
+    if (!config) throw new Error("Electrobun backend has not initialized config.");
+    return config;
+  },
+  async resetAllData(dataDir: string) {
+    await backendRequest("config.resetAllData", { dataDir });
+  },
+  async exportConfig(config: AppConfig, destPath: string) {
+    await backendRequest("config.export", { config, destPath });
+  },
+  async importConfig(dataDir: string, srcPath: string) {
+    return backendRequest<AppConfig>("config.import", { dataDir, srcPath });
+  },
+};
+
+export function installElectrobunConfigStoreHost(): void {
+  setConfigStoreHost(electrobunConfigStoreHost);
+}

package/src/renderers/electrobun/view/context-menu.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from "bun:test";
+import { contextMenuDivider, type ContextMenuItem } from "../../../types/context-menu";
+import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
+import {
+  DesktopContextMenuActionScope,
+  prepareDesktopContextMenu,
+  type DesktopContextMenuSelectMessage,
+} from "./context-menu";
+
+describe("Electrobun desktop context menu serialization", () => {
+  test("preserves roles, dividers, submenu state, accelerators, and checked state", () => {
+    const items: ContextMenuItem[] = [
+      { type: "role", role: "copy", label: "Copy", accelerator: "CmdOrCtrl+C" },
+      contextMenuDivider(),
+      {
+        id: "tools",
+        label: "Tools",
+        enabled: true,
+        checked: true,
+        accelerator: "CmdOrCtrl+T",
+        tooltip: "Open tools",
+        submenu: [
+          { id: "nested", label: "Nested", enabled: false },
+        ],
+      },
+    ];
+
+    const prepared = prepareDesktopContextMenu(items, "request-1");
+
+    expect(prepared.menu).toEqual([
+      {
+        type: "normal",
+        label: "Copy",
+        role: "copy",
+        enabled: undefined,
+        checked: undefined,
+        hidden: undefined,
+        tooltip: undefined,
+        accelerator: "CmdOrCtrl+C",
+      },
+      { type: "divider" },
+      {
+        type: "normal",
+        label: "Tools",
+        tooltip: "Open tools",
+        enabled: true,
+        checked: true,
+        hidden: undefined,
+        accelerator: "CmdOrCtrl+T",
+        action: undefined,
+        data: undefined,
+        submenu: [
+          {
+            type: "normal",
+            label: "Nested",
+            tooltip: undefined,
+            enabled: false,
+            checked: undefined,
+            hidden: undefined,
+            accelerator: undefined,
+            action: undefined,
+            data: undefined,
+            submenu: undefined,
+          },
+        ],
+      },
+    ]);
+    expect(prepared.actions.size).toBe(0);
+  });
+
+  test("custom action items get request-scoped action data and roles do not register callbacks", () => {
+    const action = () => {};
+    const prepared = prepareDesktopContextMenu([
+      { type: "role", role: "paste" },
+      { id: "open", label: "Open", onSelect: action },
+    ], "request-2");
+
+    expect(prepared.menu[0]).toMatchObject({ role: "paste" });
+    expect(prepared.menu[1]).toMatchObject({
+      action: `${ELECTROBUN_CONTEXT_MENU_ACTION}:request-2:open`,
+      data: { requestId: "request-2", itemId: "open" },
+    });
+    expect(prepared.actions.get("open")).toBe(action);
+    expect(prepared.actions.size).toBe(1);
+  });
+});
+
+describe("DesktopContextMenuActionScope", () => {
+  test("selection messages call the matching callback once", () => {
+    let listener: ((message: DesktopContextMenuSelectMessage) => void) | null = null;
+    let disposeCount = 0;
+    let runCount = 0;
+    const scope = new DesktopContextMenuActionScope(
+      (_requestId, nextListener) => {
+        listener = nextListener;
+        return () => {
+          disposeCount += 1;
+        };
+      },
+      1000,
+      (() => 1) as never,
+      (() => {}) as never,
+    );
+
+    scope.bind("request-3", new Map([["item", () => { runCount += 1; }]]));
+    listener?.({ requestId: "request-3", itemId: "item" });
+    listener?.({ requestId: "request-3", itemId: "item" });
+
+    expect(runCount).toBe(1);
+    expect(disposeCount).toBe(1);
+  });
+
+  test("stale callbacks are cleaned up after the timeout", () => {
+    let listener: ((message: DesktopContextMenuSelectMessage) => void) | null = null;
+    let timeoutCallback: (() => void) | null = null;
+    let disposeCount = 0;
+    let runCount = 0;
+    const scope = new DesktopContextMenuActionScope(
+      (_requestId, nextListener) => {
+        listener = nextListener;
+        return () => {
+          disposeCount += 1;
+        };
+      },
+      1000,
+      ((callback: () => void) => {
+        timeoutCallback = callback;
+        return 1;
+      }) as never,
+      (() => {}) as never,
+    );
+
+    scope.bind("request-4", new Map([["item", () => { runCount += 1; }]]));
+    timeoutCallback?.();
+    listener?.({ requestId: "request-4", itemId: "item" });
+
+    expect(disposeCount).toBe(1);
+    expect(runCount).toBe(0);
+  });
+});

package/src/renderers/electrobun/view/context-menu.ts

@@ -0,0 +1,164 @@
+import type { ContextMenuActionItem, ContextMenuItem, ContextMenuRoleItem } from "../../../types/context-menu";
+import { ELECTROBUN_CONTEXT_MENU_ACTION } from "../shared/protocol";
+
+export type DesktopContextMenuItem =
+  | { type: "divider" }
+  | {
+    type?: "normal";
+    label?: string;
+    tooltip?: string;
+    action?: string;
+    role?: string;
+    data?: unknown;
+    submenu?: DesktopContextMenuItem[];
+    enabled?: boolean;
+    checked?: boolean;
+    hidden?: boolean;
+    accelerator?: string;
+  };
+
+export interface PreparedDesktopContextMenu {
+  menu: DesktopContextMenuItem[];
+  actions: Map<string, () => void | Promise<void>>;
+}
+
+export interface DesktopContextMenuSelectMessage {
+  requestId: string;
+  itemId: string;
+}
+
+type ContextMenuSelectSubscribe = (
+  requestId: string,
+  listener: (message: DesktopContextMenuSelectMessage) => void,
+) => () => void;
+
+type ContextMenuTimeout = ReturnType<typeof globalThis.setTimeout>;
+type ScheduleTimeout = (callback: () => void, delayMs: number) => ContextMenuTimeout;
+type ClearScheduledTimeout = (timeout: ContextMenuTimeout) => void;
+
+function scheduleContextMenuTimeout(callback: () => void, delayMs: number): ContextMenuTimeout {
+  return globalThis.setTimeout(callback, delayMs);
+}
+
+function clearContextMenuTimeout(timeout: ContextMenuTimeout): void {
+  globalThis.clearTimeout(timeout);
+}
+
+function actionIdFor(path: readonly number[], item: ContextMenuActionItem): string {
+  return item.id || path.join(".");
+}
+
+function nativeActionFor(requestId: string, itemId: string): string {
+  return `${ELECTROBUN_CONTEXT_MENU_ACTION}:${encodeURIComponent(requestId)}:${encodeURIComponent(itemId)}`;
+}
+
+function roleItemToDesktop(item: ContextMenuRoleItem): DesktopContextMenuItem {
+  return {
+    type: "normal",
+    label: item.label,
+    role: item.role,
+    enabled: item.enabled,
+    checked: item.checked,
+    hidden: item.hidden,
+    tooltip: item.tooltip,
+    accelerator: item.accelerator,
+  };
+}
+
+function prepareItems(
+  items: readonly ContextMenuItem[],
+  requestId: string,
+  path: number[],
+  actions: Map<string, () => void | Promise<void>>,
+): DesktopContextMenuItem[] {
+  return items.map((item, index): DesktopContextMenuItem => {
+    if (item.type === "divider") return { type: "divider" };
+    if (item.type === "role") return roleItemToDesktop(item);
+
+    const itemPath = [...path, index];
+    const itemId = actionIdFor(itemPath, item);
+    if (item.onSelect) {
+      actions.set(itemId, item.onSelect);
+    }
+
+    return {
+      type: "normal",
+      label: item.label,
+      tooltip: item.tooltip,
+      enabled: item.enabled,
+      checked: item.checked,
+      hidden: item.hidden,
+      accelerator: item.accelerator,
+      action: item.onSelect ? nativeActionFor(requestId, itemId) : undefined,
+      data: item.onSelect ? { requestId, itemId } : undefined,
+      submenu: item.submenu ? prepareItems(item.submenu, requestId, itemPath, actions) : undefined,
+    };
+  });
+}
+
+export function prepareDesktopContextMenu(
+  items: readonly ContextMenuItem[],
+  requestId: string,
+): PreparedDesktopContextMenu {
+  const actions = new Map<string, () => void | Promise<void>>();
+  return {
+    menu: prepareItems(items, requestId, [], actions),
+    actions,
+  };
+}
+
+export function createContextMenuRequestId(): string {
+  return `ctx:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export class DesktopContextMenuActionScope {
+  private active:
+    | {
+      requestId: string;
+      actions: Map<string, () => void | Promise<void>>;
+      dispose: () => void;
+      timeout: ContextMenuTimeout;
+    }
+    | null = null;
+
+  constructor(
+    private readonly subscribe: ContextMenuSelectSubscribe,
+    private readonly ttlMs: number,
+    private readonly scheduleTimeout: ScheduleTimeout = scheduleContextMenuTimeout,
+    private readonly clearScheduledTimeout: ClearScheduledTimeout = clearContextMenuTimeout,
+  ) {}
+
+  clear(): void {
+    if (!this.active) return;
+    this.active.dispose();
+    this.clearScheduledTimeout(this.active.timeout);
+    this.active = null;
+  }
+
+  clearRequest(requestId: string): void {
+    if (this.active?.requestId === requestId) {
+      this.clear();
+    }
+  }
+
+  bind(requestId: string, actions: Map<string, () => void | Promise<void>>): void {
+    this.clear();
+    if (actions.size === 0) return;
+
+    const dispose = this.subscribe(requestId, (message) => {
+      const action = this.active?.actions.get(message.itemId);
+      this.clear();
+      if (!action) return;
+      void action();
+    });
+    const timeout = this.scheduleTimeout(() => {
+      this.clearRequest(requestId);
+    }, this.ttlMs);
+    this.active = {
+      requestId,
+      actions,
+      dispose,
+      timeout,
+    };
+  }
+}