gloomberb 0.5.1 → 0.6.0

package/src/renderers/electrobun/bun/window-frame.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, test } from "bun:test";
+import {
+  DEFAULT_WINDOW_FRAME,
+  MAIN_WINDOW_MIN_SIZE,
+  constrainWindowFrame,
+  normalizeWindowFrameWithMinimum,
+} from "./window-frame";
+
+describe("electrobun window frames", () => {
+  test("normalizes partial resize events without clamping usable small windows", () => {
+    const frame = normalizeWindowFrameWithMinimum(
+      { width: 720 },
+      { x: 10, y: 20, width: 1200, height: 800 },
+      MAIN_WINDOW_MIN_SIZE,
+    );
+
+    expect(frame).toEqual({
+      x: 10,
+      y: 20,
+      width: 720,
+      height: 800,
+    });
+  });
+
+  test("clamps only tiny frames to the emergency minimum size", () => {
+    expect(constrainWindowFrame(
+      { x: 0, y: 0, width: 400, height: 300 },
+      MAIN_WINDOW_MIN_SIZE,
+    )).toEqual({
+      x: 0,
+      y: 0,
+      width: 640,
+      height: 400,
+    });
+  });
+
+  test("uses the default frame when no frame data is available", () => {
+    expect(normalizeWindowFrameWithMinimum(null)).toEqual(DEFAULT_WINDOW_FRAME);
+  });
+});

package/src/renderers/electrobun/bun/window-frame.ts

@@ -0,0 +1,46 @@
+export interface WindowFrame {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface WindowMinimumSize {
+  width: number;
+  height: number;
+}
+
+export const DEFAULT_WINDOW_FRAME: WindowFrame = { x: 64, y: 48, width: 1440, height: 920 };
+// Emergency fallback until Electrobun exposes stable native minimum-size handling:
+// https://github.com/blackboardsh/electrobun/issues/188
+export const MAIN_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 640, height: 400 };
+export const DETACHED_WINDOW_MIN_SIZE: WindowMinimumSize = { width: 360, height: 240 };
+
+export function normalizeWindowFrame(
+  frame: Partial<WindowFrame> | null | undefined,
+  fallback: WindowFrame = DEFAULT_WINDOW_FRAME,
+): WindowFrame {
+  return {
+    x: typeof frame?.x === "number" ? frame.x : fallback.x,
+    y: typeof frame?.y === "number" ? frame.y : fallback.y,
+    width: typeof frame?.width === "number" ? frame.width : fallback.width,
+    height: typeof frame?.height === "number" ? frame.height : fallback.height,
+  };
+}
+
+export function constrainWindowFrame(frame: WindowFrame, minimumSize?: WindowMinimumSize): WindowFrame {
+  if (!minimumSize) return frame;
+  return {
+    ...frame,
+    width: Math.max(minimumSize.width, frame.width),
+    height: Math.max(minimumSize.height, frame.height),
+  };
+}
+
+export function normalizeWindowFrameWithMinimum(
+  frame: Partial<WindowFrame> | null | undefined,
+  fallback: WindowFrame = DEFAULT_WINDOW_FRAME,
+  minimumSize?: WindowMinimumSize,
+): WindowFrame {
+  return constrainWindowFrame(normalizeWindowFrame(frame, fallback), minimumSize);
+}

package/src/renderers/electrobun/shared/protocol.ts

@@ -0,0 +1,72 @@
+import type { AppSessionSnapshot } from "../../../core/state/session-persistence";
+import type { DesktopDockPreviewState, DesktopSharedStateSnapshot } from "../../../types/desktop-window";
+import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu";
+import type { AppConfig } from "../../../types/config";
+import type { UpdateProgress } from "../../../updater";
+import type { CapabilityManifest } from "../../../capabilities";
+
+export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
+
+export interface ElectrobunBackendInit {
+  config: AppConfig;
+  sessionSnapshot: AppSessionSnapshot | null;
+  desktopSnapshot: DesktopSharedStateSnapshot | null;
+  pluginState: Record<string, Record<string, unknown>>;
+  capabilityManifests: CapabilityManifest[];
+  windowKind: "main" | "detached";
+  paneId?: string;
+}
+
+export interface BackendRequestPayload {
+  method: string;
+  payload?: unknown;
+}
+
+export interface ContextMenuSelectMessage {
+  requestId: string;
+  itemId: string;
+}
+
+export interface ApplicationMenuSelectMessage {
+  command: DesktopApplicationMenuCommand;
+}
+
+export interface DesktopStateMessage {
+  snapshot: DesktopSharedStateSnapshot;
+}
+
+export interface DesktopDockPreviewMessage {
+  preview: DesktopDockPreviewState;
+}
+
+export interface UpdateProgressMessage {
+  progress: UpdateProgress;
+}
+
+export interface CapabilityEventMessage {
+  subscriptionId: string;
+  event: unknown;
+}
+
+export interface ElectrobunDesktopRpcSchema {
+  bun: {
+    requests: {
+      "backend.request": {
+        params: BackendRequestPayload;
+        response: unknown;
+      };
+    };
+    messages: {};
+  };
+  webview: {
+    requests: {};
+    messages: {
+      "context-menu.select": ContextMenuSelectMessage;
+      "application-menu.select": ApplicationMenuSelectMessage;
+      "desktop.state": DesktopStateMessage;
+      "desktop.dockPreview": DesktopDockPreviewMessage;
+      "update.progress": UpdateProgressMessage;
+      "capability.event": CapabilityEventMessage;
+    };
+  };
+}

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

@@ -0,0 +1,93 @@
+import {
+  AI_RUNNER_CAPABILITY_ID,
+  type AiRunnerEvent,
+} from "../../../capabilities";
+import {
+  getAiProviderDefinitions,
+  __setDetectedProvidersForTests,
+} from "../../../plugins/builtin/ai/providers";
+import { AiRunCancelledError, setAiRunHost } from "../../../plugins/builtin/ai/runner";
+import { backendRequest, onCapabilityEvent } from "./backend-rpc";
+
+let nextRunId = 1;
+
+export async function installElectrobunAiHost(): Promise<void> {
+  const availability = await backendRequest<Record<string, boolean>>("capability.invoke", {
+    capabilityId: AI_RUNNER_CAPABILITY_ID,
+    operationId: "getProviderAvailability",
+    payload: {},
+  });
+  const providers = getAiProviderDefinitions().map((definition) => ({
+    ...definition,
+    available: availability[definition.id] ?? false,
+  }));
+
+  __setDetectedProvidersForTests(providers);
+  setAiRunHost({
+    run({ provider, prompt, cwd, onChunk }) {
+      const subscriptionId = `ai-run:${nextRunId++}`;
+      let disposed = false;
+      let settled = false;
+      let disposeMessages: () => void = () => {};
+      let resolveDone: (output: string) => void = () => {};
+      let rejectDone: (error: unknown) => void = () => {};
+
+      const cleanup = () => {
+        if (disposed) return;
+        disposed = true;
+        disposeMessages();
+        void backendRequest("capability.unsubscribe", { subscriptionId }).catch(() => {});
+      };
+
+      const settle = (callback: () => void) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        callback();
+      };
+
+      const done = new Promise<string>((resolve, reject) => {
+        resolveDone = resolve;
+        rejectDone = reject;
+      });
+
+      disposeMessages = onCapabilityEvent(subscriptionId, (message) => {
+        const event = message.event as AiRunnerEvent;
+        switch (event.kind) {
+          case "chunk":
+            onChunk?.(event.output);
+            break;
+          case "done":
+            settle(() => resolveDone(event.output));
+            break;
+          case "cancelled":
+            settle(() => rejectDone(new AiRunCancelledError()));
+            break;
+          case "error":
+            settle(() => rejectDone(new Error(event.error)));
+            break;
+        }
+      });
+
+      void backendRequest("capability.subscribe", {
+        subscriptionId,
+        capabilityId: AI_RUNNER_CAPABILITY_ID,
+        operationId: "run",
+        payload: {
+          providerId: provider.id,
+          prompt,
+          cwd,
+        },
+      }).catch((error) => {
+        settle(() => rejectDone(error));
+      });
+
+      return {
+        done,
+        cancel() {
+          settle(() => rejectDone(new AiRunCancelledError()));
+        },
+      };
+    },
+  });
+}

package/src/renderers/electrobun/view/app-services.ts

@@ -0,0 +1,348 @@
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import { createRemoteBrokerAdapter } from "../../../brokers/remote-broker-adapter";
+import { NewsService } from "../../../news/aggregator";
+import { setSharedNewsService } from "../../../news/hooks";
+import { PluginRegistry } from "../../../plugins/registry";
+import type { AppServices } from "../../../core/app-services";
+import type { AppConfig } from "../../../types/config";
+import type { DataProvider, QuoteSubscriptionTarget } from "../../../types/data-provider";
+import type { Quote } from "../../../types/financials";
+import type { NewsArticle, NewsQuery } from "../../../news/types";
+import type { TickerRecord, TickerMetadata } from "../../../types/ticker";
+import { newsProvider, type CapabilityManifest } from "../../../capabilities";
+import {
+  createPersistScheduler,
+  PLUGIN_STATE_SAVE_DEBOUNCE_MS,
+  SESSION_SAVE_DEBOUNCE_MS,
+} from "../../../state/persist-scheduler";
+import { backendRequest, getElectrobunBackendInitSnapshot, onCapabilityEvent } from "./backend-rpc";
+import { DesktopMemoryResourceStore } from "./resource-store";
+import { debugLog } from "../../../utils/debug-log";
+import { measurePerf } from "../../../utils/perf-marks";
+import { getRendererBuiltinPlugins } from "../../../plugins/catalog-ui";
+
+const REMOTE_DATA_REQUEST_CACHE_LIMIT = 150;
+const servicesLog = debugLog.createLogger("services");
+const ASSET_DATA_CAPABILITY_ID = "asset-data.asset-data-router";
+const NEWS_CAPABILITY_ID = "news.core";
+
+class RemoteTickerRepository {
+  async loadAllTickers(): Promise<TickerRecord[]> {
+    return backendRequest<TickerRecord[]>("ticker.loadAll");
+  }
+
+  async loadTicker(symbol: string): Promise<TickerRecord | null> {
+    return backendRequest<TickerRecord | null>("ticker.load", { symbol });
+  }
+
+  async saveTicker(ticker: TickerRecord): Promise<void> {
+    await backendRequest("ticker.save", { ticker });
+  }
+
+  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+    const ticker: TickerRecord = { metadata };
+    await this.saveTicker(ticker);
+    return ticker;
+  }
+
+  async deleteTicker(symbol: string): Promise<void> {
+    await backendRequest("ticker.delete", { symbol });
+  }
+}
+
+type RemoteAssetDataClient = DataProvider & {
+  getNews(query: NewsQuery): Promise<NewsArticle[]>;
+};
+
+type PayloadBuilder = (...args: any[]) => Record<string, unknown>;
+
+const assetDataPayloads: Record<string, PayloadBuilder> = {
+  canProvide: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getTickerFinancials: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getQuote: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getExchangeRate: (fromCurrency) => ({ fromCurrency }),
+  search: (query, context) => ({ query, context }),
+  getSecFilings: (ticker, count, exchange, context) => ({ ticker, count, exchange, context }),
+  getHolders: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getAnalystResearch: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getCorporateActions: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getSecFilingContent: (filing) => ({ filing }),
+  getEarningsCalendar: (symbols, context) => ({ symbols, context }),
+  getArticleSummary: (url) => ({ url }),
+  getPriceHistory: (ticker, exchange, range, context) => ({ ticker, exchange, range, context }),
+  getPriceHistoryForResolution: (ticker, exchange, bufferRange, resolution, context) => ({ ticker, exchange, bufferRange, resolution, context }),
+  getDetailedPriceHistory: (ticker, exchange, startDate, endDate, barSize, context) => ({ ticker, exchange, startDate, endDate, barSize, context }),
+  getChartResolutionSupport: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getChartResolutionCapabilities: (ticker, exchange, context) => ({ ticker, exchange, context }),
+  getOptionsChain: (ticker, exchange, expirationDate, context) => ({ ticker, exchange, expirationDate, context }),
+};
+
+function findCapabilityManifest(capabilityId: string): CapabilityManifest | null {
+  return getElectrobunBackendInitSnapshot()?.capabilityManifests.find((manifest) => manifest.id === capabilityId) ?? null;
+}
+
+function getRendererOperationIds(capabilityId: string): Set<string> | null {
+  const manifest = findCapabilityManifest(capabilityId);
+  if (!manifest) return null;
+  return new Set(
+    manifest.operations
+      .filter((operation) => operation.rendererSafe)
+      .map((operation) => operation.id),
+  );
+}
+
+function hasRendererOperation(operations: Set<string> | null, operationId: string): boolean {
+  return operations === null || operations.has(operationId);
+}
+
+function createCapabilityInvoker() {
+  const requestCache = new Map<string, Promise<unknown>>();
+  return function invoke<T>(capabilityId: string, operationId: string, payload: unknown): Promise<T> {
+    const requestPayload = { capabilityId, operationId, payload };
+    const key = JSON.stringify(requestPayload);
+    const cached = requestCache.get(key);
+    if (cached) return cached as Promise<T>;
+    const promise = backendRequest<T>("capability.invoke", requestPayload).catch((error) => {
+      requestCache.delete(key);
+      throw error;
+    });
+    requestCache.set(key, promise);
+    if (requestCache.size > REMOTE_DATA_REQUEST_CACHE_LIMIT) {
+      const oldestKey = requestCache.keys().next().value;
+      if (oldestKey) requestCache.delete(oldestKey);
+    }
+    return promise;
+  };
+}
+
+function createRemoteAssetDataClient(): RemoteAssetDataClient {
+  const invoke = createCapabilityInvoker();
+  const assetDataOperations = getRendererOperationIds(ASSET_DATA_CAPABILITY_ID);
+  const newsOperations = getRendererOperationIds(NEWS_CAPABILITY_ID);
+  let nextSubscriptionId = 1;
+  const base = {
+    id: "desktop-backend",
+    name: "Gloomberb Backend",
+    getCachedFinancialsForTargets: () => new Map(),
+    getNews: (query: NewsQuery) => (
+      hasRendererOperation(newsOperations, "fetchNews")
+        ? invoke<NewsArticle[]>(NEWS_CAPABILITY_ID, "fetchNews", { query })
+        : Promise.resolve([])
+    ),
+    subscribeQuotes: (
+      targets: QuoteSubscriptionTarget[],
+      onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
+    ) => {
+      if (!hasRendererOperation(assetDataOperations, "subscribeQuotes")) return () => {};
+      const uniqueTargets = [...new Map(
+        targets.map((target) => [
+          `${target.symbol}:${target.exchange ?? ""}:${target.context?.brokerId ?? ""}:${target.context?.brokerInstanceId ?? ""}`,
+          target,
+        ] as const),
+      ).values()];
+      if (uniqueTargets.length === 0) return () => {};
+
+      const subscriptionId = `quote:${nextSubscriptionId++}`;
+      const disposeMessages = onCapabilityEvent(subscriptionId, (message) => {
+        const event = message.event as { target: QuoteSubscriptionTarget; quote: Quote };
+        onQuote(event.target, event.quote);
+      });
+      let disposed = false;
+
+      void backendRequest("capability.subscribe", {
+        subscriptionId,
+        capabilityId: ASSET_DATA_CAPABILITY_ID,
+        operationId: "subscribeQuotes",
+        payload: { targets: uniqueTargets },
+      }).catch((error) => {
+        disposeMessages();
+        console.error("Failed to subscribe to backend quotes", error);
+      });
+
+      return () => {
+        if (disposed) return;
+        disposed = true;
+        disposeMessages();
+        void backendRequest("capability.unsubscribe", { subscriptionId }).catch(() => {});
+      };
+    },
+  };
+
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string" || prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+      const buildPayload = assetDataPayloads[prop];
+      if (!buildPayload || !hasRendererOperation(assetDataOperations, prop)) return undefined;
+      return (...args: unknown[]) => invoke(ASSET_DATA_CAPABILITY_ID, prop, buildPayload(...args));
+    },
+  }) as RemoteAssetDataClient;
+}
+
+class RemoteSessionStore {
+  private snapshot = getElectrobunBackendInitSnapshot()?.sessionSnapshot ?? null;
+  private readonly scheduler = createPersistScheduler<{
+    sessionId: string;
+    value: unknown;
+    schemaVersion: number;
+  }>({
+    delayMs: SESSION_SAVE_DEBOUNCE_MS,
+    save: ({ sessionId, value, schemaVersion }) => backendRequest("session.set", { sessionId, value, schemaVersion }),
+  });
+
+  get<T>(sessionId = "app", schemaVersion = 1) {
+    if (sessionId !== "app" || !this.snapshot) return null;
+    return {
+      sessionId,
+      value: this.snapshot as T,
+      schemaVersion,
+      updatedAt: Date.now(),
+    };
+  }
+
+  set(sessionId: string, value: unknown, schemaVersion = 1): void {
+    if (sessionId === "app") this.snapshot = value as typeof this.snapshot;
+    this.scheduler.schedule({ sessionId, value, schemaVersion });
+  }
+
+  delete(sessionId: string): void {
+    if (sessionId === "app") this.snapshot = null;
+    this.scheduler.cancel();
+    void backendRequest("session.delete", { sessionId }).catch(() => {});
+  }
+
+  flush(): Promise<void> {
+    return this.scheduler.flush();
+  }
+}
+
+class RemotePluginStateStore {
+  private readonly state = new Map<string, Map<string, unknown>>();
+  private readonly schedulers = new Map<string, ReturnType<typeof createPersistScheduler<{
+    pluginId: string;
+    key: string;
+    value: unknown;
+    schemaVersion: number;
+  }>>>();
+
+  constructor(initial: Record<string, Record<string, unknown>>) {
+    for (const [pluginId, values] of Object.entries(initial)) {
+      this.state.set(pluginId, new Map(Object.entries(values)));
+    }
+  }
+
+  get<T>(pluginId: string, key: string, schemaVersion = 1) {
+    const value = this.state.get(pluginId)?.get(key);
+    if (value == null) return null;
+    return { value: value as T, schemaVersion, updatedAt: Date.now() };
+  }
+
+  set(pluginId: string, key: string, value: unknown, schemaVersion = 1): void {
+    if (!this.state.has(pluginId)) this.state.set(pluginId, new Map());
+    this.state.get(pluginId)!.set(key, value);
+    this.getScheduler(pluginId, key).schedule({ pluginId, key, value, schemaVersion });
+  }
+
+  delete(pluginId: string, key: string): void {
+    this.state.get(pluginId)?.delete(key);
+    this.getScheduler(pluginId, key).cancel();
+    void backendRequest("pluginState.delete", { pluginId, key }).catch(() => {});
+  }
+
+  keys(pluginId: string): string[] {
+    return [...(this.state.get(pluginId)?.keys() ?? [])];
+  }
+
+  clear(pluginId: string): void {
+    this.state.delete(pluginId);
+  }
+
+  async flush(): Promise<void> {
+    await Promise.all([...this.schedulers.values()].map((scheduler) => scheduler.flush()));
+  }
+
+  private getScheduler(pluginId: string, key: string) {
+    const schedulerKey = `${pluginId}\u0000${key}`;
+    let scheduler = this.schedulers.get(schedulerKey);
+    if (!scheduler) {
+      scheduler = createPersistScheduler({
+        delayMs: PLUGIN_STATE_SAVE_DEBOUNCE_MS,
+        save: (entry) => backendRequest("pluginState.set", entry),
+      });
+      this.schedulers.set(schedulerKey, scheduler);
+    }
+    return scheduler;
+  }
+}
+
+class RemotePersistence {
+  readonly tickers = {};
+  readonly resources = new DesktopMemoryResourceStore();
+  readonly pluginState = new RemotePluginStateStore(getElectrobunBackendInitSnapshot()?.pluginState ?? {});
+  readonly sessions = new RemoteSessionStore();
+  close(): void {
+    void this.sessions.flush();
+    void this.pluginState.flush();
+  }
+}
+
+export function createAppServices({ config }: { config: AppConfig }): AppServices {
+  servicesLog.info("create desktop web services start", {
+    brokerInstanceCount: config.brokerInstances.length,
+  });
+  const persistence = measurePerf("startup.services.persistence", () => new RemotePersistence());
+  const tickerRepository = measurePerf("startup.services.ticker-repository", () => new RemoteTickerRepository());
+  const dataProvider = measurePerf("startup.services.data-provider", () => createRemoteAssetDataClient());
+  const marketData = new MarketDataCoordinator(dataProvider);
+  const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository as never, persistence as never, {
+    enableCapabilityHandlers: false,
+    wrapBrokerAdapter: (broker) => createRemoteBrokerAdapter(broker),
+  });
+  const newsService = new NewsService();
+
+  pluginRegistry.getConfigFn = () => config;
+  pluginRegistry.getLayoutFn = () => config.layout;
+  pluginRegistry.registerNewsCapabilityFn = () => () => {};
+  pluginRegistry.watchNewsQueryFn = (query, listener) => newsService.watchQuery(query, listener);
+
+  setSharedMarketDataCoordinator(marketData);
+  setSharedNewsService(newsService);
+
+  newsService.register(newsProvider({
+    id: dataProvider.id,
+    name: dataProvider.name,
+    priority: 0,
+    provider: {
+      fetchNews: (query) => dataProvider.getNews(query),
+    },
+  }));
+
+  const plugins = getRendererBuiltinPlugins();
+  for (const plugin of plugins) {
+    measurePerf("startup.services.register-plugin", () => {
+      void pluginRegistry.register(plugin);
+    }, { pluginId: plugin.id });
+  }
+  measurePerf("startup.services.news-start", () => {
+    newsService.start();
+  });
+  servicesLog.info("create desktop web services complete", { pluginCount: plugins.length });
+
+  return {
+    persistence: persistence as never,
+    tickerRepository: tickerRepository as never,
+    providerRouter: dataProvider as never,
+    dataProvider,
+    marketData,
+    pluginRegistry,
+    newsService,
+    destroy() {
+      setSharedMarketDataCoordinator(null);
+      setSharedNewsService(null);
+      newsService.stop();
+      pluginRegistry.destroy();
+      persistence.close();
+    },
+  };
+}

package/src/renderers/electrobun/view/application-menu-bridge.ts

@@ -0,0 +1,12 @@
+import type { DesktopApplicationMenuBridge } from "../../../types/desktop-menu";
+import { onApplicationMenuSelect } from "./backend-rpc";
+
+export function createApplicationMenuBridge(): DesktopApplicationMenuBridge {
+  return {
+    subscribe(listener) {
+      return onApplicationMenuSelect((message) => {
+        listener(message.command);
+      });
+    },
+  };
+}