gloomberb 0.2.0 → 0.3.2

package/src/state/app-activity.test.ts

@@ -0,0 +1,41 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { EventEmitter } from "events";
+import { CliRenderEvents } from "@opentui/core";
+import { bindAppActivity, isAppActive, setAppActive } from "./app-activity";
+
+afterEach(() => {
+  setAppActive(true);
+});
+
+describe("app activity", () => {
+  test("ignores blur until focus reporting has been established", () => {
+    const renderer = new EventEmitter() as any;
+    const unbind = bindAppActivity(renderer);
+
+    renderer.emit(CliRenderEvents.BLUR);
+    expect(isAppActive()).toBe(true);
+
+    renderer.emit(CliRenderEvents.FOCUS);
+    renderer.emit(CliRenderEvents.BLUR);
+    expect(isAppActive()).toBe(false);
+
+    unbind();
+  });
+
+  test("tracks renderer focus state", () => {
+    const renderer = new EventEmitter() as any;
+    const unbind = bindAppActivity(renderer);
+
+    expect(isAppActive()).toBe(true);
+
+    renderer.emit(CliRenderEvents.FOCUS);
+    renderer.emit(CliRenderEvents.BLUR);
+    expect(isAppActive()).toBe(false);
+
+    renderer.emit(CliRenderEvents.FOCUS);
+    expect(isAppActive()).toBe(true);
+
+    unbind();
+    expect(isAppActive()).toBe(true);
+  });
+});

package/src/state/app-activity.ts

@@ -0,0 +1,106 @@
+import { CliRenderEvents, type CliRenderer } from "@opentui/core";
+import { useSyncExternalStore } from "react";
+import { debugLog } from "../utils/debug-log";
+
+const activityLog = debugLog.createLogger("app-activity");
+
+class AppActivityController {
+  private active = true;
+  private hasSeenFocus = false;
+  private boundRenderer: CliRenderer | null = null;
+  private teardownRenderer: (() => void) | null = null;
+  private readonly listeners = new Set<() => void>();
+
+  bindRenderer(renderer: CliRenderer): () => void {
+    if (this.boundRenderer === renderer && this.teardownRenderer) {
+      return this.teardownRenderer;
+    }
+
+    this.teardownRenderer?.();
+    activityLog.info("bind renderer");
+
+    const handleFocus = () => {
+      this.hasSeenFocus = true;
+      activityLog.info("focus event");
+      this.setActive(true);
+    };
+    const handleBlur = () => {
+      // Some terminals can emit an initial blur before they ever report focus.
+      // Fail open until focus reporting has proven itself.
+      if (!this.hasSeenFocus) {
+        activityLog.warn("ignored blur before first focus");
+        return;
+      }
+      activityLog.info("blur event");
+      this.setActive(false);
+    };
+    const handleDestroy = () => this.reset();
+
+    renderer.on(CliRenderEvents.FOCUS, handleFocus);
+    renderer.on(CliRenderEvents.BLUR, handleBlur);
+    renderer.on(CliRenderEvents.DESTROY, handleDestroy);
+
+    this.boundRenderer = renderer;
+    this.teardownRenderer = () => {
+      renderer.off(CliRenderEvents.FOCUS, handleFocus);
+      renderer.off(CliRenderEvents.BLUR, handleBlur);
+      renderer.off(CliRenderEvents.DESTROY, handleDestroy);
+      if (this.boundRenderer === renderer) {
+        this.boundRenderer = null;
+        this.teardownRenderer = null;
+      }
+      activityLog.info("unbind renderer");
+      this.reset();
+    };
+
+    return this.teardownRenderer;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+
+  setActive(active: boolean): void {
+    if (this.active === active) return;
+    this.active = active;
+    activityLog.info("activity changed", { active });
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+
+  reset(): void {
+    this.hasSeenFocus = false;
+    activityLog.info("reset activity state");
+    this.setActive(true);
+  }
+}
+
+const controller = new AppActivityController();
+
+export function bindAppActivity(renderer: CliRenderer): () => void {
+  return controller.bindRenderer(renderer);
+}
+
+export function isAppActive(): boolean {
+  return controller.isActive();
+}
+
+export function setAppActive(active: boolean): void {
+  controller.setActive(active);
+}
+
+export function useAppActive(): boolean {
+  return useSyncExternalStore(
+    (listener) => controller.subscribe(listener),
+    () => controller.isActive(),
+    () => true,
+  );
+}

package/src/state/app-bootstrap.test.ts

@@ -0,0 +1,471 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { AppPersistence } from "../data/app-persistence";
+import { TickerRepository } from "../data/ticker-repository";
+import { createDefaultConfig, type BrokerInstanceConfig } from "../types/config";
+import type { AppAction } from "./app-context";
+import { initializeAppState } from "./app-bootstrap";
+
+const tempPaths: string[] = [];
+
+function createTempDbPath(name: string): string {
+  const path = join(tmpdir(), `gloomberb-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  tempPaths.push(path);
+  return path;
+}
+
+afterEach(() => {
+  for (const path of tempPaths.splice(0)) {
+    if (existsSync(path)) rmSync(path, { force: true });
+  }
+});
+
+describe("initializeAppState", () => {
+  test("hydrates persisted broker account snapshots into app state before broker sync", async () => {
+    const dbPath = createTempDbPath("app-bootstrap");
+    const persistence = new AppPersistence(dbPath);
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const brokerInstance: BrokerInstanceConfig = {
+      id: "ibkr-live",
+      brokerType: "ibkr",
+      label: "Interactive Brokers",
+      connectionMode: "gateway",
+      config: { connectionMode: "gateway", gateway: { host: "127.0.0.1", port: 4002, clientId: 1 } },
+      enabled: true,
+    };
+    const config = {
+      ...createDefaultConfig(dbPath),
+      brokerInstances: [brokerInstance],
+    };
+
+    const actions: AppAction[] = [];
+
+    await initializeAppState({
+      config,
+      tickerRepository,
+      dataProvider: {} as any,
+      sessionSnapshot: null,
+      dispatch: (action) => { actions.push(action); },
+      refreshTicker: () => {},
+      refreshQuote: () => {},
+      autoImportBrokerPositions: async () => {},
+      persistedBrokerAccounts: {
+        "ibkr-live": [{
+          accountId: "DU12345",
+          name: "DU12345",
+          currency: "USD",
+          source: "gateway",
+          updatedAt: 1_717_000_000_000,
+          totalCashValue: 125000,
+        }],
+      },
+    });
+
+    expect(actions).toContainEqual({
+      type: "SET_BROKER_ACCOUNTS",
+      instanceId: "ibkr-live",
+      accounts: [{
+        accountId: "DU12345",
+        name: "DU12345",
+        currency: "USD",
+        source: "gateway",
+        updatedAt: 1_717_000_000_000,
+        totalCashValue: 125000,
+      }],
+    });
+
+    const initializedIndex = actions.findIndex((action) => action.type === "SET_INITIALIZED");
+    const brokerAccountsIndex = actions.findIndex((action) =>
+      action.type === "SET_BROKER_ACCOUNTS" && action.instanceId === "ibkr-live"
+    );
+    expect(brokerAccountsIndex).toBeGreaterThan(-1);
+    expect(initializedIndex).toBeGreaterThan(brokerAccountsIndex);
+
+    persistence.close();
+  });
+
+  test("uses quote warmup for quote-only collection panes and financial warmup for ticker panes", async () => {
+    const dbPath = createTempDbPath("app-bootstrap-refresh-plan");
+    const persistence = new AppPersistence(dbPath);
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const defaultConfig = createDefaultConfig(dbPath);
+    const quoteOnlyConfig = {
+      ...defaultConfig,
+      layout: {
+        ...defaultConfig.layout,
+        dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        instances: defaultConfig.layout.instances
+          .filter((instance) => instance.paneId === "portfolio-list")
+          .map((instance) => ({
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: ["ticker", "price", "change_pct", "latency"],
+            },
+          })),
+      },
+      layouts: defaultConfig.layouts.map((entry) => ({
+        ...entry,
+        layout: {
+          ...entry.layout,
+          dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+          instances: entry.layout.instances
+            .filter((instance) => instance.paneId === "portfolio-list")
+            .map((instance) => ({
+              ...instance,
+              settings: {
+                ...(instance.settings ?? {}),
+                columnIds: ["ticker", "price", "change_pct", "latency"],
+              },
+            })),
+        },
+      })),
+    };
+
+    await tickerRepository.createTicker({
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+
+    const quoteRefreshes: string[] = [];
+    const financialRefreshes: string[] = [];
+
+    await initializeAppState({
+      config: quoteOnlyConfig,
+      tickerRepository,
+      dataProvider: {} as any,
+      sessionSnapshot: null,
+      dispatch: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
+      refreshQuote: (symbol) => { quoteRefreshes.push(symbol); },
+      autoImportBrokerPositions: async () => {},
+    });
+
+    expect(quoteRefreshes).toEqual(["AAPL"]);
+    expect(financialRefreshes).toEqual([]);
+
+    quoteRefreshes.length = 0;
+    financialRefreshes.length = 0;
+
+    await initializeAppState({
+      config: defaultConfig,
+      tickerRepository,
+      dataProvider: {} as any,
+      sessionSnapshot: null,
+      dispatch: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
+      refreshQuote: (symbol) => { quoteRefreshes.push(symbol); },
+      autoImportBrokerPositions: async () => {},
+    });
+
+    expect(financialRefreshes).toEqual(["AAPL"]);
+    expect(quoteRefreshes).toEqual([]);
+
+    persistence.close();
+  });
+
+  test("uses financial warmup for collection panes that show fundamentals columns", async () => {
+    const dbPath = createTempDbPath("app-bootstrap-financial-collection");
+    const persistence = new AppPersistence(dbPath);
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const defaultConfig = createDefaultConfig(dbPath);
+    const financialCollectionConfig = {
+      ...defaultConfig,
+      layout: {
+        ...defaultConfig.layout,
+        dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        instances: defaultConfig.layout.instances
+          .filter((instance) => instance.paneId === "portfolio-list")
+          .map((instance) => ({
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: ["ticker", "market_cap", "pe", "forward_pe"],
+            },
+          })),
+      },
+      layouts: defaultConfig.layouts.map((entry) => ({
+        ...entry,
+        layout: {
+          ...entry.layout,
+          dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+          instances: entry.layout.instances
+            .filter((instance) => instance.paneId === "portfolio-list")
+            .map((instance) => ({
+              ...instance,
+              settings: {
+                ...(instance.settings ?? {}),
+                columnIds: ["ticker", "market_cap", "pe", "forward_pe"],
+              },
+            })),
+        },
+      })),
+    };
+
+    await tickerRepository.createTicker({
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+
+    const quoteRefreshes: string[] = [];
+    const financialRefreshes: string[] = [];
+
+    await initializeAppState({
+      config: financialCollectionConfig,
+      tickerRepository,
+      dataProvider: {} as any,
+      sessionSnapshot: null,
+      dispatch: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
+      refreshQuote: (symbol) => { quoteRefreshes.push(symbol); },
+      autoImportBrokerPositions: async () => {},
+    });
+
+    expect(financialRefreshes).toEqual(["AAPL"]);
+    expect(quoteRefreshes).toEqual([]);
+
+    persistence.close();
+  });
+
+  test("restores background hydration targets even when another collection row is selected", async () => {
+    const dbPath = createTempDbPath("app-bootstrap-hydration-targets");
+    const persistence = new AppPersistence(dbPath);
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const defaultConfig = createDefaultConfig(dbPath);
+    const quoteOnlyConfig = {
+      ...defaultConfig,
+      layout: {
+        ...defaultConfig.layout,
+        dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        instances: defaultConfig.layout.instances
+          .filter((instance) => instance.paneId === "portfolio-list")
+          .map((instance) => ({
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: ["ticker", "price", "change_pct", "latency"],
+            },
+          })),
+      },
+      layouts: defaultConfig.layouts.map((entry) => ({
+        ...entry,
+        layout: {
+          ...entry.layout,
+          dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+          instances: entry.layout.instances
+            .filter((instance) => instance.paneId === "portfolio-list")
+            .map((instance) => ({
+              ...instance,
+              settings: {
+                ...(instance.settings ?? {}),
+                columnIds: ["ticker", "price", "change_pct", "latency"],
+              },
+            })),
+        },
+      })),
+    };
+
+    await tickerRepository.createTicker({
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+    await tickerRepository.createTicker({
+      ticker: "NVDA",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "NVIDIA Corporation",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+
+    const quoteRefreshes: string[] = [];
+    const financialRefreshes: string[] = [];
+
+    await initializeAppState({
+      config: quoteOnlyConfig,
+      tickerRepository,
+      dataProvider: {} as any,
+      sessionSnapshot: {
+        paneState: {
+          "portfolio-list:main": {
+            collectionId: "main",
+            cursorSymbol: "NVDA",
+          },
+        },
+        focusedPaneId: "portfolio-list:main",
+        activePanel: "left",
+        statusBarVisible: true,
+        openPaneIds: ["portfolio-list:main"],
+        hydrationTargets: [{
+          symbol: "AAPL",
+          exchange: "NASDAQ",
+          instrument: null,
+        }],
+        exchangeCurrencies: [],
+        savedAt: Date.now(),
+      },
+      dispatch: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
+      refreshQuote: (symbol) => { quoteRefreshes.push(symbol); },
+      autoImportBrokerPositions: async () => {},
+    });
+
+    expect(quoteRefreshes).toEqual(["NVDA"]);
+    expect(financialRefreshes).toEqual(["AAPL"]);
+
+    persistence.close();
+  });
+
+  test("primes cached financials for background hydration targets before initialization", async () => {
+    const dbPath = createTempDbPath("app-bootstrap-prime-cached-financials");
+    const persistence = new AppPersistence(dbPath);
+    const tickerRepository = new TickerRepository(persistence.tickers);
+    const defaultConfig = createDefaultConfig(dbPath);
+    const quoteOnlyConfig = {
+      ...defaultConfig,
+      layout: {
+        ...defaultConfig.layout,
+        dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+        instances: defaultConfig.layout.instances
+          .filter((instance) => instance.paneId === "portfolio-list")
+          .map((instance) => ({
+            ...instance,
+            settings: {
+              ...(instance.settings ?? {}),
+              columnIds: ["ticker", "price", "change_pct", "latency"],
+            },
+          })),
+      },
+      layouts: defaultConfig.layouts.map((entry) => ({
+        ...entry,
+        layout: {
+          ...entry.layout,
+          dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+          instances: entry.layout.instances
+            .filter((instance) => instance.paneId === "portfolio-list")
+            .map((instance) => ({
+              ...instance,
+              settings: {
+                ...(instance.settings ?? {}),
+                columnIds: ["ticker", "price", "change_pct", "latency"],
+              },
+            })),
+        },
+      })),
+    };
+
+    await tickerRepository.createTicker({
+      ticker: "AAPL",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "Apple Inc.",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+    await tickerRepository.createTicker({
+      ticker: "NVDA",
+      exchange: "NASDAQ",
+      currency: "USD",
+      name: "NVIDIA Corporation",
+      portfolios: [],
+      watchlists: ["main"],
+      positions: [],
+      broker_contracts: [],
+      custom: {},
+      tags: [],
+    });
+
+    const events: string[] = [];
+
+    await initializeAppState({
+      config: quoteOnlyConfig,
+      tickerRepository,
+      dataProvider: {
+        id: "test-provider",
+        name: "Test Provider",
+        getCachedFinancialsForTargets: () => new Map([["AAPL", {
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+          quote: {
+            symbol: "AAPL",
+            price: 200,
+            currency: "USD",
+            change: 1,
+            changePercent: 0.5,
+            marketCap: 2_000_000_000,
+            lastUpdated: Date.now(),
+          },
+          fundamentals: {
+            trailingPE: 25,
+          },
+        }]]),
+      } as any,
+      sessionSnapshot: {
+        paneState: {
+          "portfolio-list:main": {
+            collectionId: "main",
+            cursorSymbol: "NVDA",
+          },
+        },
+        focusedPaneId: "portfolio-list:main",
+        activePanel: "left",
+        statusBarVisible: true,
+        openPaneIds: ["portfolio-list:main"],
+        hydrationTargets: [{
+          symbol: "AAPL",
+          exchange: "NASDAQ",
+          instrument: null,
+        }],
+        exchangeCurrencies: [],
+        savedAt: Date.now(),
+      },
+      dispatch: (action) => { events.push(action.type); },
+      primeCachedFinancials: (entries) => {
+        events.push(`prime:${entries.map((entry) => entry.ticker.metadata.ticker).join(",")}`);
+      },
+      refreshTicker: () => {},
+      refreshQuote: () => {},
+      autoImportBrokerPositions: async () => {},
+    });
+
+    expect(events).toContain("prime:AAPL");
+    expect(events.indexOf("prime:AAPL")).toBeLessThan(events.indexOf("SET_INITIALIZED"));
+
+    persistence.close();
+  });
+});