gloomberb 0.5.1 → 0.6.0

package/src/renderers/electrobun/view/desktop-window-snapshot.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import { createDefaultConfig } from "../../../types/config";
+import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
+import { detachedSnapshotKey } from "./desktop-window-snapshot";
+
+function createSnapshot(): DesktopSharedStateSnapshot {
+  const config = createDefaultConfig("/tmp/gloomberb-test");
+  config.layout.detached = [{ instanceId: "ticker-detail:main", x: 20, y: 20, width: 640, height: 420 }];
+  return {
+    config,
+    paneState: {
+      "portfolio-list:main": { cursorSymbol: "AAPL", collectionId: "main" },
+      "ticker-detail:main": { activeTabId: "overview" },
+    },
+    focusedPaneId: "portfolio-list:main",
+    activePanel: "left",
+    statusBarVisible: true,
+  };
+}
+
+describe("detached desktop snapshots", () => {
+  test("ignores unrelated window state", () => {
+    const snapshot = createSnapshot();
+    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
+
+    expect(detachedSnapshotKey({
+      ...snapshot,
+      activePanel: "right",
+      focusedPaneId: "chat:main",
+      paneState: {
+        ...snapshot.paneState,
+        "chat:main": { draft: "unrelated" },
+      },
+    }, "ticker-detail:main")).toBe(key);
+  });
+
+  test("tracks the detached pane and its follow source", () => {
+    const snapshot = createSnapshot();
+    const key = detachedSnapshotKey(snapshot, "ticker-detail:main");
+
+    expect(detachedSnapshotKey({
+      ...snapshot,
+      paneState: {
+        ...snapshot.paneState,
+        "ticker-detail:main": { activeTabId: "financials" },
+      },
+    }, "ticker-detail:main")).not.toBe(key);
+
+    expect(detachedSnapshotKey({
+      ...snapshot,
+      paneState: {
+        ...snapshot.paneState,
+        "portfolio-list:main": { cursorSymbol: "MSFT", collectionId: "main" },
+      },
+    }, "ticker-detail:main")).not.toBe(key);
+  });
+});

package/src/renderers/electrobun/view/desktop-window-snapshot.ts

@@ -0,0 +1,41 @@
+import { findPaneInstance } from "../../../types/config";
+import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
+
+export function prepareDetachedSnapshot(
+  snapshot: DesktopSharedStateSnapshot,
+  paneId: string,
+): DesktopSharedStateSnapshot {
+  return snapshot.focusedPaneId === paneId ? snapshot : { ...snapshot, focusedPaneId: paneId };
+}
+
+function collectPaneStateIds(snapshot: DesktopSharedStateSnapshot, paneId: string): string[] {
+  const ids: string[] = [];
+  const seen = new Set<string>();
+  let currentPaneId: string | null = paneId;
+
+  while (currentPaneId && !seen.has(currentPaneId)) {
+    seen.add(currentPaneId);
+    ids.push(currentPaneId);
+
+    const instance = findPaneInstance(snapshot.config.layout, currentPaneId);
+    currentPaneId = instance?.binding?.kind === "follow" ? instance.binding.sourceInstanceId : null;
+  }
+
+  return ids;
+}
+
+export function detachedSnapshotKey(snapshot: DesktopSharedStateSnapshot, paneId: string): string {
+  const paneStateIds = collectPaneStateIds(snapshot, paneId);
+  return JSON.stringify({
+    theme: snapshot.config.theme,
+    baseCurrency: snapshot.config.baseCurrency,
+    portfolios: snapshot.config.portfolios,
+    watchlists: snapshot.config.watchlists,
+    brokerInstances: snapshot.config.brokerInstances,
+    pluginConfig: snapshot.config.pluginConfig,
+    disabledPlugins: snapshot.config.disabledPlugins,
+    chartPreferences: snapshot.config.chartPreferences,
+    instances: paneStateIds.map((id) => findPaneInstance(snapshot.config.layout, id) ?? null),
+    paneState: Object.fromEntries(paneStateIds.map((id) => [id, snapshot.paneState[id] ?? {}])),
+  });
+}

package/src/renderers/electrobun/view/dialog-host.tsx

@@ -0,0 +1,62 @@
+/// <reference lib="dom" />
+/** @jsxImportSource react */
+import { useCallback, useMemo, useState, type ReactNode } from "react";
+import { DialogHostProvider, type DialogApi } from "../../../ui/dialog";
+
+interface DialogState {
+  id: string;
+  content: ReactNode | ((context: { dialogId: string; dismiss(): void; resolve(value: unknown): void }) => ReactNode);
+  resolve(value: unknown): void;
+}
+
+let nextDialogId = 1;
+
+export function WebDialogHostProvider({ children }: { children: ReactNode }) {
+  const [dialogState, setDialogState] = useState<DialogState | null>(null);
+
+  const close = useCallback((value?: unknown) => {
+    setDialogState((current) => {
+      current?.resolve(value);
+      return null;
+    });
+  }, []);
+
+  const open = useCallback((options: Record<string, unknown>) => (
+    new Promise<unknown>((resolve) => {
+      setDialogState({
+        id: `web-dialog-${nextDialogId++}`,
+        content: options.content as DialogState["content"],
+        resolve,
+      });
+    })
+  ), []);
+
+  const api = useMemo<DialogApi>(() => ({
+    alert: open,
+    prompt: open,
+  }), [open]);
+
+  return (
+    <DialogHostProvider dialog={api} isOpen={dialogState !== null}>
+      {children}
+      {dialogState && (
+        <div
+          className="gloom-dialog-backdrop"
+          onMouseDown={(event) => {
+            if (event.target === event.currentTarget) close(undefined);
+          }}
+        >
+          <div className="gloom-dialog">
+            {typeof dialogState.content === "function"
+              ? dialogState.content({
+                dialogId: dialogState.id,
+                dismiss: () => close(undefined),
+                resolve: close,
+              })
+              : dialogState.content}
+          </div>
+        </div>
+      )}
+    </DialogHostProvider>
+  );
+}

package/src/renderers/electrobun/view/http-fetch.ts

@@ -0,0 +1,113 @@
+/// <reference lib="dom" />
+import { setCloudApiFetchTransport } from "../../../utils/api-client";
+import { setHttpFetchTransport } from "../../../utils/http-transport";
+import { backendRequest } from "./backend-rpc";
+
+interface ElectrobunHttpFetchResponse {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  setCookie?: string[];
+  body: string;
+}
+
+function normalizeHeaders(headers: HeadersInit | undefined): Record<string, string> {
+  const normalized: Record<string, string> = {};
+  if (!headers) return normalized;
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      normalized[key] = value;
+    });
+    return normalized;
+  }
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      normalized[key] = value;
+    }
+    return normalized;
+  }
+  return { ...headers };
+}
+
+function createAbortError(): Error {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+
+async function serializeBody(body: BodyInit | null | undefined): Promise<string | undefined> {
+  if (body == null) return undefined;
+  if (typeof body === "string") return body;
+  return new Response(body).text();
+}
+
+function withAbort<T>(promise: Promise<T>, signal: AbortSignal | null | undefined): Promise<T> {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    throw createAbortError();
+  }
+  return new Promise<T>((resolve, reject) => {
+    const abort = () => reject(createAbortError());
+    signal.addEventListener("abort", abort, { once: true });
+    void promise.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", abort);
+    });
+  });
+}
+
+async function electrobunHttpFetch(url: string, init?: RequestInit): Promise<Response> {
+  if (init?.signal?.aborted) {
+    throw createAbortError();
+  }
+
+  const requestPromise = requestBackendHttpFetch(url, init);
+
+  const response = await withAbort(requestPromise, init?.signal);
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+async function requestBackendHttpFetch(url: string, init?: RequestInit): Promise<ElectrobunHttpFetchResponse> {
+  return backendRequest<ElectrobunHttpFetchResponse>("http.fetch", {
+    url,
+    init: {
+      method: init?.method,
+      headers: normalizeHeaders(init?.headers),
+      body: await serializeBody(init?.body),
+    },
+  });
+}
+
+function createResponseHeaders(headers: Record<string, string>, setCookie: string[] = []): Headers {
+  const responseHeaders = new Headers(headers);
+  if (setCookie.length === 0) return responseHeaders;
+
+  const originalGet = responseHeaders.get.bind(responseHeaders);
+  responseHeaders.get = ((name: string) => (
+    name.toLowerCase() === "set-cookie" ? setCookie[0] ?? null : originalGet(name)
+  )) as Headers["get"];
+  (responseHeaders as Headers & { getSetCookie?: () => string[] }).getSetCookie = () => [...setCookie];
+  return responseHeaders;
+}
+
+async function electrobunCloudApiFetch(url: string, init?: RequestInit): Promise<Response> {
+  const response = await requestBackendHttpFetch(url, init);
+
+  return {
+    ok: response.status >= 200 && response.status < 300,
+    status: response.status,
+    statusText: response.statusText,
+    headers: createResponseHeaders(response.headers, response.setCookie),
+    text: async () => response.body,
+  } as Response;
+}
+
+export function installElectrobunHttpFetchTransport(): void {
+  setHttpFetchTransport(electrobunHttpFetch);
+}
+
+export function installElectrobunCloudApiFetchTransport(): void {
+  setCloudApiFetchTransport(electrobunCloudApiFetch);
+}

package/src/renderers/electrobun/view/input-host.tsx

@@ -0,0 +1,65 @@
+/// <reference lib="dom" />
+/** @jsxImportSource react */
+import { useEffect, useMemo, useSyncExternalStore, type ReactNode } from "react";
+import { InputHostProvider, type InputHost, type KeyEventLike } from "../../../react/input";
+import { hasWebCtrlModifier, normalizeWebKeyName, shouldConsumeWebAppKeyDown, webKeySequence } from "./key-event";
+
+export const WEB_CELL_WIDTH = 8;
+export const WEB_CELL_HEIGHT = 18;
+
+function toKeyEventLike(event: KeyboardEvent): KeyEventLike {
+  const key = normalizeWebKeyName(event.key);
+  return {
+    key,
+    name: key,
+    sequence: webKeySequence(event),
+    ctrl: hasWebCtrlModifier(event),
+    shift: event.shiftKey,
+    alt: event.altKey,
+    meta: event.metaKey,
+    super: event.metaKey,
+    preventDefault: () => event.preventDefault(),
+    stopPropagation: () => event.stopPropagation(),
+  };
+}
+
+function subscribeViewport(listener: () => void): () => void {
+  window.addEventListener("resize", listener);
+  return () => window.removeEventListener("resize", listener);
+}
+
+let viewportSnapshot = { width: 0, height: 0 };
+
+function getViewport() {
+  const width = Math.max(1, window.innerWidth / WEB_CELL_WIDTH);
+  const height = Math.max(1, window.innerHeight / WEB_CELL_HEIGHT);
+  if (viewportSnapshot.width !== width || viewportSnapshot.height !== height) {
+    viewportSnapshot = { width, height };
+  }
+  return viewportSnapshot;
+}
+
+export function WebInputHostProvider({ children }: { children: ReactNode }) {
+  const host = useMemo<InputHost>(() => ({
+    useShortcut(handler, options) {
+      useEffect(() => {
+        if (options?.enabled === false) return;
+        const onKeyDown = (event: KeyboardEvent) => {
+          handler(toKeyEventLike(event));
+          if (shouldConsumeWebAppKeyDown(event)) event.preventDefault();
+        };
+        window.addEventListener("keydown", onKeyDown);
+        return () => window.removeEventListener("keydown", onKeyDown);
+      }, [handler, options?.enabled, options?.scope]);
+    },
+    useViewport() {
+      return useSyncExternalStore(subscribeViewport, getViewport, getViewport);
+    },
+  }), []);
+
+  return (
+    <InputHostProvider host={host}>
+      {children}
+    </InputHostProvider>
+  );
+}

package/src/renderers/electrobun/view/key-event.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { shouldConsumeWebAppKeyDown } from "./key-event";
+
+function keyEvent(overrides: Record<string, unknown>) {
+  return {
+    key: "x",
+    ctrlKey: false,
+    metaKey: false,
+    shiftKey: false,
+    target: null,
+    ...overrides,
+  } as never;
+}
+
+describe("shouldConsumeWebAppKeyDown", () => {
+  test("consumes non-editable app keydowns", () => {
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "+" }))).toBe(true);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "ArrowDown", target: { tagName: "DIV" } }))).toBe(true);
+  });
+
+  test("preserves native editing and control targets", () => {
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ target: { tagName: "INPUT" } }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ target: { tagName: "TEXTAREA" } }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ target: { tagName: "DIV", isContentEditable: true } }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "Enter", target: { tagName: "BUTTON" } }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "+", target: { tagName: "BUTTON" } }))).toBe(true);
+  });
+
+  test("preserves browser modifier shortcuts unless they are terminal-style ctrl-shift shortcuts", () => {
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "c", ctrlKey: true }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "c", metaKey: true }))).toBe(false);
+    expect(shouldConsumeWebAppKeyDown(keyEvent({ key: "c", ctrlKey: true, shiftKey: true }))).toBe(true);
+  });
+});

package/src/renderers/electrobun/view/key-event.ts

@@ -0,0 +1,134 @@
+/// <reference lib="dom" />
+
+type KeyboardTargetLike = EventTarget & {
+  tagName?: string;
+  nodeName?: string;
+  isContentEditable?: boolean;
+  closest?: (selector: string) => unknown;
+  getAttribute?: (name: string) => string | null;
+};
+
+type WebKeyDefaultEvent = Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey" | "shiftKey" | "target"> & {
+  defaultPrevented?: boolean;
+  isComposing?: boolean;
+};
+
+function controlLetterForKey(key: string): string | null {
+  if (key.length !== 1) return null;
+  const code = key.charCodeAt(0);
+  if (code < 1 || code > 26) return null;
+  return String.fromCharCode(96 + code);
+}
+
+function getKeyboardTarget(target: EventTarget | null): KeyboardTargetLike | null {
+  if (!target || typeof target !== "object") return null;
+  return target as KeyboardTargetLike;
+}
+
+function getTargetTagName(target: KeyboardTargetLike): string {
+  return (target.tagName ?? target.nodeName ?? "").toUpperCase();
+}
+
+function targetHasClosest(target: KeyboardTargetLike, selector: string): boolean {
+  if (typeof target.closest !== "function") return false;
+  try {
+    return target.closest(selector) != null;
+  } catch {
+    return false;
+  }
+}
+
+function isEditableKeyboardTarget(target: EventTarget | null): boolean {
+  const element = getKeyboardTarget(target);
+  if (!element) return false;
+
+  const tagName = getTargetTagName(element);
+  if (tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT") {
+    return true;
+  }
+  if (element.isContentEditable === true) return true;
+
+  const contentEditable = element.getAttribute?.("contenteditable");
+  return contentEditable === "" || contentEditable?.toLowerCase() === "true"
+    || targetHasClosest(element, "input, textarea, select, [contenteditable=''], [contenteditable='true']");
+}
+
+function isNativeKeyboardControlTarget(target: EventTarget | null): boolean {
+  const element = getKeyboardTarget(target);
+  if (!element) return false;
+
+  const tagName = getTargetTagName(element);
+  if (tagName === "BUTTON" || tagName === "A" || tagName === "SUMMARY") return true;
+
+  return targetHasClosest(element, "button, a[href], summary");
+}
+
+function isBrowserModifierShortcut(event: WebKeyDefaultEvent): boolean {
+  if (event.metaKey) return true;
+  if (!event.ctrlKey || event.shiftKey) return false;
+
+  const key = normalizeWebKeyName(event.key);
+  return key === "c" || key === "v" || key === "x" || key === "a";
+}
+
+function isNativeControlActivationKey(event: WebKeyDefaultEvent): boolean {
+  const key = normalizeWebKeyName(event.key);
+  return key === "return" || key === "enter" || key === "space";
+}
+
+export function shouldConsumeWebAppKeyDown(event: WebKeyDefaultEvent): boolean {
+  if (event.defaultPrevented || event.isComposing) return false;
+  if (isEditableKeyboardTarget(event.target)) return false;
+  if (isBrowserModifierShortcut(event)) return false;
+  if (isNativeKeyboardControlTarget(event.target) && isNativeControlActivationKey(event)) return false;
+  return true;
+}
+
+export function normalizeWebKeyName(key: string): string {
+  const controlLetter = controlLetterForKey(key);
+  if (controlLetter) return controlLetter;
+
+  switch (key) {
+    case " ":
+      return "space";
+    case "ArrowUp":
+      return "up";
+    case "ArrowDown":
+      return "down";
+    case "ArrowLeft":
+      return "left";
+    case "ArrowRight":
+      return "right";
+    case "Enter":
+      return "return";
+    case "Escape":
+      return "escape";
+    case "Backspace":
+      return "backspace";
+    case "Delete":
+      return "delete";
+    case "Tab":
+      return "tab";
+    default:
+      return key.length === 1 ? key.toLowerCase() : key.toLowerCase();
+  }
+}
+
+export function hasWebCtrlModifier(event: KeyboardEvent): boolean {
+  return event.ctrlKey || controlLetterForKey(event.key) !== null;
+}
+
+export function webKeySequence(event: KeyboardEvent): string {
+  switch (event.key) {
+    case "Enter":
+      return "\r";
+    case "Escape":
+      return "\x1b";
+    case "Tab":
+      return "\t";
+    case "Backspace":
+      return "\x7f";
+    default:
+      return event.key;
+  }
+}

package/src/renderers/electrobun/view/main.tsx

@@ -0,0 +1,104 @@
+/// <reference lib="dom" />
+/** @jsxImportSource react */
+import { createRoot } from "react-dom/client";
+import { App } from "../../../app";
+import { UiHostProvider } from "../../../ui/host";
+import { debugLog } from "../../../utils/debug-log";
+import { measurePerfAsync } from "../../../utils/perf-marks";
+import { startMainThreadMonitor } from "../../../utils/main-thread-monitor";
+import { initElectrobunBackend } from "./backend-rpc";
+import { installElectrobunAiHost } from "./ai-host";
+import { installElectrobunBrokerRemoteClient } from "./broker-remote-client";
+import { installElectrobunConfigStoreHost } from "./config-host";
+import { WebDialogHostProvider } from "./dialog-host";
+import {
+  installElectrobunCloudApiFetchTransport,
+  installElectrobunHttpFetchTransport,
+} from "./http-fetch";
+import { installElectrobunUpdateHost } from "./update-host";
+import { WebInputHostProvider } from "./input-host";
+import { webNativeRenderer } from "./native-renderer";
+import { WebToastHostProvider } from "./toast-host";
+import { webRendererHost, webUiHost } from "./ui-host";
+import { createApplicationMenuBridge } from "./application-menu-bridge";
+import { createDesktopWindowBridge } from "./desktop-window-bridge";
+import { prepareDetachedSnapshot } from "./desktop-window-snapshot";
+
+const rootElement = document.getElementById("root");
+if (!rootElement) {
+  throw new Error("Missing root element");
+}
+
+const root = createRoot(rootElement);
+const bootLog = debugLog.createLogger("electrobun-web-boot");
+const ELECTROBUN_WEB_CONSOLE_LOG_SOURCES = [
+  "app",
+  "main-thread",
+  "perf",
+  "refresh-queue",
+  "services",
+  "startup",
+  "electrobun-web-boot",
+];
+debugLog.mirrorToConsole({
+  sources: ELECTROBUN_WEB_CONSOLE_LOG_SOURCES,
+});
+const stopMainThreadMonitor = startMainThreadMonitor("electrobun.web", { mirrorToConsole: true });
+
+root.render(<div className="gloom-loading">Starting Gloomberb...</div>);
+bootLog.warn("diagnostic console mirror enabled", { sources: ELECTROBUN_WEB_CONSOLE_LOG_SOURCES });
+
+async function boot() {
+  bootLog.info("boot started");
+  const backendInitPromise = initElectrobunBackend();
+  // Avoid a premature global unhandled-rejection render while UI chunks load.
+  void backendInitPromise.catch(() => {});
+
+  installElectrobunConfigStoreHost();
+  installElectrobunBrokerRemoteClient();
+  installElectrobunHttpFetchTransport();
+  installElectrobunCloudApiFetchTransport();
+  installElectrobunUpdateHost();
+  const init = await measurePerfAsync("startup.electrobun.backend-init", () => backendInitPromise);
+  await installElectrobunAiHost();
+  const desktopSnapshot = init.windowKind === "detached" && init.paneId && init.desktopSnapshot
+    ? prepareDetachedSnapshot(init.desktopSnapshot, init.paneId)
+    : init.desktopSnapshot;
+  const config = desktopSnapshot?.config ?? init.config;
+  const desktopWindowBridge = createDesktopWindowBridge(init.windowKind, init.paneId);
+  const desktopApplicationMenuBridge = createApplicationMenuBridge();
+  measurePerfAsync("startup.electrobun.root-render", async () => {
+    root.render(
+      <UiHostProvider ui={webUiHost} renderer={webRendererHost} nativeRenderer={webNativeRenderer}>
+        <WebInputHostProvider>
+          <WebToastHostProvider>
+            <WebDialogHostProvider>
+              <App
+                config={config}
+                desktopWindowBridge={desktopWindowBridge}
+                desktopApplicationMenuBridge={desktopApplicationMenuBridge}
+                desktopSnapshot={desktopSnapshot}
+              />
+            </WebDialogHostProvider>
+          </WebToastHostProvider>
+        </WebInputHostProvider>
+      </UiHostProvider>,
+    );
+  });
+  bootLog.info("root render scheduled", {
+    layoutPanes: config.layout.instances.length,
+    floatingPanes: config.layout.floating.length,
+    detachedPanes: config.layout.detached.length,
+    brokerInstances: config.brokerInstances.length,
+  });
+}
+
+boot().catch((error) => {
+  stopMainThreadMonitor();
+  root.render(
+    <div className="gloom-fatal">
+      <h1>Gloomberb failed to start</h1>
+      <pre>{error instanceof Error ? error.stack ?? error.message : String(error)}</pre>
+    </div>,
+  );
+});