gloomberb 0.9.5 → 0.9.7

package/src/plugins/builtin/portfolio-list/pane/streaming.ts

@@ -5,10 +5,13 @@ import { useQuoteStreaming } from "../../../../state/hooks/quote-streaming";
 import type { TickerFinancials } from "../../../../types/financials";
 import type { TickerRecord } from "../../../../types/ticker";
 import {
-  VISIBLE_FINANCIAL_REFRESH_COOLDOWN_MS,
   VISIBLE_FINANCIAL_WARMUP_DELAY_MS,
+  VISIBLE_QUOTE_REFRESH_COOLDOWN_MS,
+  VISIBLE_QUOTE_STREAM_WATCHDOG_MS,
   VISIBLE_SNAPSHOT_WARMUP_BATCH_LIMIT,
+  VISIBLE_SNAPSHOT_REFRESH_COOLDOWN_MS,
   needsVisibleQuoteWarmup,
+  needsVisibleQuoteWatchdogRefresh,
   needsVisibleSnapshotWarmup,
   selectStreamTickers,
   visibleWarmupKey,
@@ -90,7 +93,7 @@ export function usePortfolioPaneStreaming({
       if (
         needsVisibleQuoteWarmup(financials, nowTimestamp)
         && !warmupInFlightRef.current.has(quoteKey)
-        && nowTimestamp - (warmupAttemptRef.current.get(quoteKey) ?? 0) >= VISIBLE_FINANCIAL_REFRESH_COOLDOWN_MS
+        && nowTimestamp - (warmupAttemptRef.current.get(quoteKey) ?? 0) >= VISIBLE_QUOTE_REFRESH_COOLDOWN_MS
       ) {
         quoteQueue.push(ticker);
         continue;
@@ -100,7 +103,7 @@ export function usePortfolioPaneStreaming({
       if (
         needsVisibleSnapshotWarmup(ticker, financials, visibleWarmupRequirements)
         && !warmupInFlightRef.current.has(snapshotKey)
-        && nowTimestamp - (warmupAttemptRef.current.get(snapshotKey) ?? 0) >= VISIBLE_FINANCIAL_REFRESH_COOLDOWN_MS
+        && nowTimestamp - (warmupAttemptRef.current.get(snapshotKey) ?? 0) >= VISIBLE_SNAPSHOT_REFRESH_COOLDOWN_MS
       ) {
         snapshotQueue.push(ticker);
       }
@@ -130,7 +133,7 @@ export function usePortfolioPaneStreaming({
       try {
         await Promise.allSettled([
           quoteEntries.length > 0
-            ? sharedCoordinator.loadQuotesBatch(quoteEntries.map((entry) => entry.instrument))
+            ? sharedCoordinator.loadQuotesBatch(quoteEntries.map((entry) => entry.instrument), { forceRefresh: true })
             : Promise.resolve(),
           snapshotEntries.length > 0
             ? sharedCoordinator.loadSnapshotsBatch(snapshotEntries.map((entry) => entry.instrument))
@@ -155,5 +158,52 @@ export function usePortfolioPaneStreaming({
     };
   }, [appActive, financialsMap, focused, sharedCoordinator, visibleFinancialTickers, visibleWarmupRequirements]);
 
+  useEffect(() => {
+    if (!appActive) return;
+    if (!focused) return;
+    if (!sharedCoordinator) return;
+
+    let cancelled = false;
+    const runWatchdog = async (): Promise<void> => {
+      const nowTimestamp = Date.now();
+      const quoteEntries = visibleFinancialTickers.flatMap((ticker) => {
+        const financials = financialsMap.get(ticker.metadata.ticker);
+        const key = visibleWarmupKey("quote", ticker);
+        if (
+          !needsVisibleQuoteWatchdogRefresh(financials, nowTimestamp)
+          || warmupInFlightRef.current.has(key)
+          || nowTimestamp - (warmupAttemptRef.current.get(key) ?? 0) < VISIBLE_QUOTE_REFRESH_COOLDOWN_MS
+        ) {
+          return [];
+        }
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+        if (!instrument) return [];
+        warmupInFlightRef.current.add(key);
+        warmupAttemptRef.current.set(key, nowTimestamp);
+        return [{ key, instrument }];
+      });
+      if (quoteEntries.length === 0) return;
+
+      try {
+        await sharedCoordinator.loadQuotesBatch(quoteEntries.map((entry) => entry.instrument), { forceRefresh: true });
+      } catch {
+        // Best-effort watchdog for visible rows only.
+      } finally {
+        for (const entry of quoteEntries) {
+          warmupInFlightRef.current.delete(entry.key);
+        }
+      }
+    };
+
+    const intervalId = setInterval(() => {
+      if (!cancelled && mountedRef.current) void runWatchdog();
+    }, VISIBLE_QUOTE_STREAM_WATCHDOG_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(intervalId);
+    };
+  }, [appActive, financialsMap, focused, sharedCoordinator, visibleFinancialTickers]);
+
   useQuoteStreaming(streamTargets);
 }

package/src/plugins/builtin/portfolio-list/settings.ts

@@ -3,11 +3,13 @@ import { DEFAULT_COLUMNS, DEFAULT_PORTFOLIO_COLUMN_IDS, type AppConfig, type Col
 import { PRICE_SPARKLINE_COLUMN_ID, PRICE_SPARKLINE_PERIOD_LABEL } from "../../../components/price-sparkline/view";
 
 type CollectionScope = "all" | "portfolios" | "watchlists" | "custom";
+export type PortfolioViewMode = "table" | "grid";
 
 export interface PortfolioPaneSettings {
   columnIds: string[];
   collectionScope: CollectionScope;
   visibleCollectionIds: string[];
+  viewMode: PortfolioViewMode;
   hideHeader: boolean;
   hideCash: boolean;
 }
@@ -95,11 +97,27 @@ const COLLECTION_SCOPE_OPTIONS: PaneSettingOption[] = [
     description: "Choose exactly which collections this pane should show.",
   },
 ];
+const VIEW_MODE_OPTIONS: PaneSettingOption[] = [
+  {
+    value: "table",
+    label: "Table",
+    description: "Show positions in the portfolio table.",
+  },
+  {
+    value: "grid",
+    label: "Grid",
+    description: "Show positions in the portfolio grid.",
+  },
+];
 
 function isCollectionScope(value: unknown): value is CollectionScope {
   return value === "all" || value === "portfolios" || value === "watchlists" || value === "custom";
 }
 
+function isPortfolioViewMode(value: unknown): value is PortfolioViewMode {
+  return value === "table" || value === "grid";
+}
+
 function filterCollectionEntries(entries: CollectionEntry[], settings: PortfolioPaneSettings): CollectionEntry[] {
   switch (settings.collectionScope) {
     case "portfolios":
@@ -142,6 +160,7 @@ export function getPortfolioPaneSettings(settings: Record<string, unknown> | und
     columnIds: columnIds.length > 0 ? columnIds : DEFAULT_PORTFOLIO_COLUMN_IDS,
     collectionScope: isCollectionScope(settings?.collectionScope) ? settings.collectionScope : "all",
     visibleCollectionIds,
+    viewMode: isPortfolioViewMode(settings?.viewMode) ? settings.viewMode : "table",
     hideHeader: settings?.hideHeader === true,
     hideCash: settings?.hideCash === true,
   };
@@ -218,9 +237,15 @@ export function resolveVisibleColumns(columnIds: string[], isPortfolioTab: boole
     .filter((column) => isPortfolioTab || !PORTFOLIO_ONLY_COLUMN_IDS.has(column.id));
 }
 
-export function buildPortfolioPaneSettingsDef(config: AppConfig, settings: PortfolioPaneSettings): PaneSettingsDef {
+export function buildPortfolioPaneSettingsDef(
+  config: AppConfig,
+  settings: PortfolioPaneSettings,
+  activeCollectionId?: string | null,
+): PaneSettingsDef {
   const collectionEntries = getCollectionEntries(config);
   const allCollectionOptions = resolveCollectionOptions(collectionEntries);
+  const activeCollectionIsPortfolio = !!activeCollectionId
+    && config.portfolios.some((portfolio) => portfolio.id === activeCollectionId);
 
   const fields: PaneSettingsDef["fields"] = [
     {
@@ -241,6 +266,15 @@ export function buildPortfolioPaneSettingsDef(config: AppConfig, settings: Portf
     },
   ];
 
+  if (activeCollectionIsPortfolio) {
+    fields.push({
+      key: "viewMode",
+      label: "View",
+      type: "select",
+      options: VIEW_MODE_OPTIONS,
+    });
+  }
+
   if (settings.collectionScope === "custom") {
     fields.push({
       key: "visibleCollectionIds",
@@ -266,6 +300,7 @@ export function buildPortfolioPaneSettingsDef(config: AppConfig, settings: Portf
       ...settings,
       columnIds: [...settings.columnIds],
       visibleCollectionIds: [...settings.visibleCollectionIds],
+      viewMode: settings.viewMode,
     },
     fields,
   };

package/src/plugins/ibkr/gateway/service/index.test.ts

@@ -1,4 +1,7 @@
 import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 import { BarSizeSetting, ConnectionState, SecType, type ContractDetails } from "@stoqey/ib";
 import { Subject, of } from "rxjs";
 import {
@@ -246,6 +249,25 @@ test("remote gateway snapshots are side-effect-free", async () => {
   }
 });
 
+test("native gateway loader bundles without a runtime ./native specifier", async () => {
+  const outdir = mkdtempSync(join(tmpdir(), "gloomberb-ibkr-service-"));
+  try {
+    const result = await Bun.build({
+      entrypoints: [join(import.meta.dir, "index.ts")],
+      outdir,
+      target: "bun",
+    });
+
+    expect(result.success).toBe(true);
+    const entry = readFileSync(join(outdir, "index.js"), "utf8");
+    expect(entry).toContain("src/plugins/ibkr/gateway/service/native.ts");
+    expect(entry).not.toContain('"./native"');
+    expect(entry).not.toContain("'./native'");
+  } finally {
+    rmSync(outdir, { recursive: true, force: true });
+  }
+});
+
 describe("tick-by-tick quote updates", () => {
   const contract = {
     symbol: "AAPL",

package/src/plugins/ibkr/gateway/service/index.ts

@@ -17,18 +17,18 @@ import type {
   IbkrSnapshot,
   ResolvedIbkrGatewayConnection,
 } from "../types";
+import {
+  loadNativeGatewayModule as loadDefaultNativeGatewayModule,
+  type NativeGatewayModule,
+} from "./native-loader";
 
 export type {
   IbkrGatewayConfig,
   ResolvedIbkrGatewayConnection,
 } from "../types";
 
-type NativeGatewayService = any;
 type NativeGatewayManager = any;
-type NativeGatewayModule = {
-  ibkrGatewayManager: NativeGatewayManager;
-  setResolvedIbkrGatewayListener(listener: ResolvedGatewayListener | null): void;
-};
+type NativeGatewayService = any;
 type Listener = () => void;
 type ResolvedGatewayListener = (
   instanceId: string | undefined,
@@ -47,9 +47,6 @@ let loadedNativeGatewayModule: NativeGatewayModule | null = null;
 let nativeGatewayModulePromise: Promise<NativeGatewayModule> | null = null;
 let nativeGatewayManager: NativeGatewayManager | null = null;
 let nativeGatewayModuleLoader: () => Promise<NativeGatewayModule>;
-const importNativeGatewayModule = new Function("specifier", "return import(specifier)") as (
-  specifier: string,
-) => Promise<NativeGatewayModule>;
 
 const snapshots = new Map<string, IbkrSnapshot>();
 const listeners = new Map<string, Set<Listener>>();
@@ -60,7 +57,7 @@ function getSnapshotEntry(instanceId?: string): IbkrSnapshot {
 }
 
 function defaultNativeGatewayModuleLoader(): Promise<NativeGatewayModule> {
-  return importNativeGatewayModule("./native");
+  return loadDefaultNativeGatewayModule();
 }
 
 nativeGatewayModuleLoader = defaultNativeGatewayModuleLoader;

package/src/plugins/ibkr/gateway/service/native-loader.ts

@@ -0,0 +1,12 @@
+import type { ResolvedIbkrGatewayConnection } from "../types";
+
+export type NativeGatewayModule = {
+  ibkrGatewayManager: any;
+  setResolvedIbkrGatewayListener(
+    listener: ((instanceId: string | undefined, connection: ResolvedIbkrGatewayConnection) => void | Promise<void>) | null,
+  ): void;
+};
+
+export function loadNativeGatewayModule(): Promise<NativeGatewayModule> {
+  return import("./native");
+}

package/src/remote/app-host.tsx

@@ -0,0 +1,77 @@
+import { useEffect, useMemo } from "react";
+import type { Dispatch } from "react";
+import type { PluginRegistry } from "../plugins/registry";
+import type { AppAction, AppState } from "../state/app/context";
+import type { DesktopWindowBridge } from "../types/desktop-window";
+import { createAppRemoteController } from "./controller";
+import { useRemoteUiRegistry } from "./semantic-tree";
+import type { RemoteControlRequest, RemoteControlResponse } from "./types";
+
+export type RemoteControlHandler = (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
+
+export interface RemoteControlAdapter {
+  startServer?(options: { dataDir: string; handle: RemoteControlHandler }): void | (() => void | Promise<void>);
+  registerHandler?(handler: RemoteControlHandler | null): void | (() => void);
+}
+
+interface RemoteControlHostProps {
+  adapter?: RemoteControlAdapter;
+  dispatch: Dispatch<AppAction>;
+  getState: () => AppState;
+  pluginRegistry: PluginRegistry;
+  desktopWindowBridge?: DesktopWindowBridge;
+}
+
+export function RemoteControlHost({
+  adapter,
+  dispatch,
+  getState,
+  pluginRegistry,
+  desktopWindowBridge,
+}: RemoteControlHostProps) {
+  const uiRegistry = useRemoteUiRegistry();
+  const controller = useMemo(() => createAppRemoteController({
+    dispatch,
+    getState,
+    pluginRegistry,
+    uiRegistry,
+    desktopWindowBridge,
+    afterMutation: async () => {
+      await Promise.resolve();
+      await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+          if (settled) return;
+          settled = true;
+          resolve(undefined);
+        };
+        if (typeof requestAnimationFrame === "function") {
+          requestAnimationFrame(finish);
+        }
+        setTimeout(finish, 50);
+      });
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    },
+  }), [desktopWindowBridge, dispatch, getState, pluginRegistry, uiRegistry]);
+  const dataDir = getState().config.dataDir;
+
+  useEffect(() => {
+    if (!adapter?.startServer) return;
+    const cleanup = adapter.startServer({ dataDir, handle: controller.handle });
+    if (!cleanup) return;
+    return () => {
+      void cleanup();
+    };
+  }, [adapter, controller, dataDir]);
+
+  useEffect(() => {
+    if (!adapter?.registerHandler) return;
+    const cleanup = adapter.registerHandler(controller.handle);
+    if (!cleanup) return;
+    return () => {
+      cleanup();
+    };
+  }, [adapter, controller]);
+
+  return null;
+}

package/src/remote/client.ts

@@ -0,0 +1,34 @@
+import type { RemoteAppKind, RemoteControlRequest, RemoteControlResponse } from "./types";
+import { readRemoteEndpoint } from "./endpoint";
+
+export interface SendRemoteControlRequestOptions {
+  dataDir: string;
+  appKind?: RemoteAppKind;
+}
+
+export async function sendRemoteControlRequest(
+  request: RemoteControlRequest,
+  options: SendRemoteControlRequestOptions,
+): Promise<RemoteControlResponse> {
+  const endpoint = await readRemoteEndpoint(options.dataDir, options.appKind);
+  const response = await fetch(`http://127.0.0.1:${endpoint.port}/rpc`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${endpoint.token}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(request),
+  });
+  const payload = await response.json() as RemoteControlResponse;
+  if (!response.ok && payload.ok !== false) {
+    return {
+      ok: false,
+      error: {
+        code: "remote_http_error",
+        message: `Remote control request failed with HTTP ${response.status}.`,
+        details: payload,
+      },
+    };
+  }
+  return payload;
+}

package/src/remote/command-bar.ts

@@ -0,0 +1,98 @@
+import type { AppState } from "../state/app/context";
+import type { RemoteUiNodeSnapshot } from "./types";
+
+export function commandBarResultsFromNodes(nodes: RemoteUiNodeSnapshot[]) {
+  const directResults = nodes
+    .filter((node) => node.role === "command-bar-result")
+    .map((node) => {
+      const metadata = node.metadata ?? {};
+      const item = metadata.item && typeof metadata.item === "object"
+        ? metadata.item as Record<string, unknown>
+        : {};
+      return {
+        nodeId: node.id,
+        index: metadata.index,
+        label: node.label ?? item.label,
+        detail: item.detail,
+        category: item.category,
+        kind: item.kind,
+        right: item.right,
+        selected: metadata.selected === true,
+        disabled: node.disabled === true,
+        actions: node.actions,
+        itemId: item.id,
+        actionInput: undefined,
+        metadata,
+      };
+    });
+
+  const listResults = nodes.flatMap((node) => {
+    const metadata = node.metadata ?? {};
+    if (node.role !== "list" && node.role !== "command-bar-list") return [];
+    if (metadata.scope !== "command-bar") return [];
+    const rawItems = Array.isArray(metadata.items) ? metadata.items : [];
+    const selectedIndex = typeof metadata.selectedIndex === "number" ? metadata.selectedIndex : -1;
+    return rawItems
+      .map((entry, fallbackIndex) => (
+        entry && typeof entry === "object"
+          ? entry as Record<string, unknown>
+          : { label: String(entry), index: fallbackIndex }
+      ))
+      .map((item, fallbackIndex) => {
+        const index = typeof item.index === "number" ? item.index : fallbackIndex;
+        return {
+          nodeId: node.id,
+          index,
+          label: item.label,
+          detail: item.detail,
+          category: item.category ?? metadata.category,
+          kind: item.kind ?? metadata.itemKind,
+          right: item.right,
+          selected: selectedIndex === index,
+          disabled: item.disabled === true || node.disabled === true,
+          actions: node.actions,
+          itemId: item.id,
+          actionInput: {
+            index,
+            id: item.id,
+            label: item.label,
+          },
+          metadata: {
+            ...metadata,
+            item,
+          },
+        };
+      });
+  });
+
+  return [...directResults, ...listResults].sort((left, right) => {
+    const leftIndex = typeof left.index === "number" ? left.index : Number.MAX_SAFE_INTEGER;
+    const rightIndex = typeof right.index === "number" ? right.index : Number.MAX_SAFE_INTEGER;
+    return leftIndex - rightIndex;
+  });
+}
+
+export function isCommandBarInputNode(node: RemoteUiNodeSnapshot): boolean {
+  return (
+    (node.role === "input" || node.role === "command-bar-input")
+    && node.metadata?.scope === "command-bar"
+  );
+}
+
+function commandBarInputValue(nodes: RemoteUiNodeSnapshot[], fallback: string): string {
+  const focusedInput = nodes.find((node) => isCommandBarInputNode(node) && node.metadata?.focused === true);
+  const value = focusedInput?.metadata?.value;
+  return typeof value === "string" ? value : fallback;
+}
+
+export function commandBarSnapshot(state: AppState, nodes: RemoteUiNodeSnapshot[]) {
+  const results = commandBarResultsFromNodes(nodes);
+  return {
+    open: state.commandBarOpen,
+    query: commandBarInputValue(nodes, state.commandBarQuery),
+    stateQuery: state.commandBarQuery,
+    launchRequest: state.commandBarLaunchRequest,
+    selectedIndex: results.find((result) => result.selected)?.index ?? null,
+    results,
+  };
+}

package/src/remote/controller-utils.ts

@@ -0,0 +1,111 @@
+import { getDockedPaneIds } from "../plugins/pane-manager";
+import type { AppState } from "../state/app/context";
+import type { LayoutConfig, PaneInstanceConfig } from "../types/config";
+import { revisionFor } from "./revision";
+import type { RemoteControlResponse, RemoteIncludedState, RemoteStateInclude } from "./types";
+
+export interface PatchTarget<T> {
+  value: T;
+  apply(value: T): Promise<void> | void;
+}
+
+export function ok<T>(data: T, rev?: string, state?: RemoteIncludedState): RemoteControlResponse<T> {
+  return {
+    ok: true,
+    data,
+    ...(rev ? { rev } : {}),
+    ...(state ? { state } : {}),
+  };
+}
+
+export function fail(code: string, error: unknown): RemoteControlResponse {
+  return {
+    ok: false,
+    error: {
+      code,
+      message: error instanceof Error ? error.message : String(error),
+    },
+  };
+}
+
+export function asRecord(input: unknown): Record<string, unknown> {
+  return input && typeof input === "object" && !Array.isArray(input) ? input as Record<string, unknown> : {};
+}
+
+export function stringInput(input: Record<string, unknown>, key: string): string {
+  const value = input[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${key} is required.`);
+  }
+  return value;
+}
+
+export function optionalString(input: Record<string, unknown>, key: string): string | undefined {
+  const value = input[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export function numberInput(input: Record<string, unknown>, key: string): number {
+  const value = input[key];
+  if (!Number.isInteger(value)) {
+    throw new Error(`${key} must be an integer.`);
+  }
+  return value as number;
+}
+
+export function optionalNumber(input: Record<string, unknown>, key: string): number | undefined {
+  const value = input[key];
+  return Number.isInteger(value) ? value as number : undefined;
+}
+
+export function activeLayoutRev(state: AppState): string {
+  return revisionFor({
+    layout: state.config.layout,
+    paneState: state.paneState,
+    focusedPaneId: state.focusedPaneId,
+    activePanel: state.activePanel,
+  });
+}
+
+export function panePlacement(layout: LayoutConfig, instanceId: string): "docked" | "floating" | "detached" | "hidden" {
+  if (getDockedPaneIds(layout).includes(instanceId)) return "docked";
+  if (layout.floating.some((entry) => entry.instanceId === instanceId)) return "floating";
+  if ((layout.detached ?? []).some((entry) => entry.instanceId === instanceId)) return "detached";
+  return "hidden";
+}
+
+export function paneSnapshot(state: AppState, pane: PaneInstanceConfig) {
+  return {
+    ...pane,
+    placement: panePlacement(state.config.layout, pane.instanceId),
+    focused: state.focusedPaneId === pane.instanceId,
+    runtimeState: state.paneState[pane.instanceId] ?? {},
+  };
+}
+
+export function mutationSummary(state: AppState, extra: Record<string, unknown> = {}) {
+  return {
+    ok: true,
+    rev: activeLayoutRev(state),
+    activeLayoutIndex: state.config.activeLayoutIndex,
+    activeLayoutName: state.config.layouts[state.config.activeLayoutIndex]?.name ?? null,
+    focusedPaneId: state.focusedPaneId,
+    commandBarOpen: state.commandBarOpen,
+    commandBarQuery: state.commandBarQuery,
+    dockedPaneIds: getDockedPaneIds(state.config.layout),
+    floatingPaneIds: state.config.layout.floating.map((entry) => entry.instanceId),
+    detachedPaneIds: (state.config.layout.detached ?? []).map((entry) => entry.instanceId),
+    ...extra,
+  };
+}
+
+export function normalizeIncludes(
+  include: RemoteStateInclude[] | undefined,
+  defaults: RemoteStateInclude[] = [],
+): RemoteStateInclude[] {
+  const raw = include ?? defaults;
+  if (raw.includes("all")) {
+    return ["app", "layout", "panes", "commandBar", "ui", "schema", "help"];
+  }
+  return [...new Set(raw)];
+}