gloomberb 0.7.3 → 0.7.4

package/src/sources/yahoo-finance.test.ts

@@ -33,6 +33,43 @@ describe("YahooFinanceClient exchange aliases", () => {
     expect(history[0]?.close).toBe(200);
   });
 
+  test("maps IBKR option symbols to Yahoo option quote marks", async () => {
+    const provider = new YahooFinanceClient() as any;
+    provider.getOptionsChain = async (ticker: string, _exchange: string, expirationDate: number) => ({
+      underlyingSymbol: ticker,
+      expirationDates: [expirationDate],
+      calls: [{
+        contractSymbol: "AMD270917C00230000",
+        strike: 230,
+        currency: "USD",
+        lastPrice: 251,
+        change: 1.5,
+        percentChange: 0.6,
+        volume: 10,
+        openInterest: 20,
+        bid: 250.25,
+        ask: 254.5,
+        impliedVolatility: 0.4,
+        inTheMoney: false,
+        expiration: expirationDate,
+        lastTradeDate: 1_800_000_000,
+      }],
+      puts: [],
+    });
+
+    const quote = await provider.getQuote("AMD   270917C00230000");
+
+    expect(quote).toMatchObject({
+      symbol: "AMD   270917C00230000",
+      price: 252.375,
+      mark: 252.375,
+      bid: 250.25,
+      ask: 254.5,
+      providerId: "yahoo",
+    });
+    expect(quote.lastUpdated).toBe(1_800_000_000_000);
+  });
+
   test("preserves analyst rating price targets from upgrade history", async () => {
     const provider = new YahooFinanceClient() as any;
     let requestUrl = "";

package/src/sources/yahoo-finance.ts

@@ -7,6 +7,7 @@ import {
   type ManualChartResolution,
 } from "../components/chart/chart-resolution";
 import type { InstrumentSearchResult } from "../types/instrument";
+import { parseOptionSymbol } from "../utils/options";
 import { SecEdgarClient } from "./sec-edgar";
 
 // Exchange suffix mapping for Yahoo Finance ticker symbols
@@ -755,7 +756,7 @@ export class YahooFinanceClient implements DataProvider {
     const history: PricePoint[] = [];
     for (let i = 0; i < result.timestamp.length; i++) {
       const close = quote.close?.[i];
-      if (close == null || Number.isNaN(close)) continue;
+      if (close == null || !Number.isFinite(close) || close <= 0) continue;
       history.push({
         date: new Date((result.timestamp[i]!) * 1000),
         open: quote.open?.[i] ?? undefined,
@@ -1047,8 +1048,53 @@ export class YahooFinanceClient implements DataProvider {
     };
   }
 
+  private async getOptionQuote(ticker: string, context?: MarketDataRequestContext): Promise<Quote> {
+    const parsed = parseOptionSymbol(ticker);
+    if (!parsed) throw new Error(`Unsupported option symbol ${ticker}`);
+    const chain = await this.getOptionsChain(parsed.underlying, "", parsed.expTs, context);
+    const contracts = parsed.side === "C" ? chain.calls : chain.puts;
+    const contract = contracts.find((candidate) =>
+      Math.abs(candidate.strike - parsed.strike) < 0.001 &&
+      candidate.expiration === parsed.expTs
+    );
+    if (!contract) throw new Error(`No option contract for ${ticker}`);
+
+    const mark = contract.bid > 0 && contract.ask > 0
+      ? (contract.bid + contract.ask) / 2
+      : contract.bid > 0
+        ? contract.bid
+        : contract.ask > 0
+          ? contract.ask
+          : undefined;
+    return {
+      symbol: ticker,
+      providerId: this.id,
+      price: mark ?? contract.lastPrice,
+      currency: contract.currency || "USD",
+      change: contract.change,
+      changePercent: contract.percentChange,
+      volume: contract.volume,
+      bid: contract.bid,
+      ask: contract.ask,
+      mark,
+      name: contract.contractSymbol,
+      lastUpdated: contract.lastTradeDate > 0
+        ? contract.lastTradeDate * 1000
+        : Date.now(),
+      exchangeName: "OPTIONS",
+      fullExchangeName: "OPTIONS",
+      listingExchangeName: "OPTIONS",
+      listingExchangeFullName: "OPTIONS",
+      dataSource: "delayed",
+    };
+  }
+
   /** Fetch just a quote (lighter weight) */
-  async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
+  async getQuote(ticker: string, exchange = "", context?: MarketDataRequestContext): Promise<Quote> {
+    if (parseOptionSymbol(ticker)) {
+      return this.getOptionQuote(ticker, context);
+    }
+
     const symbolsToTry = this.getSymbolsToTry(ticker, exchange);
     let lastError: any;
 

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

@@ -408,8 +408,28 @@ describe("initializeAppState", () => {
       custom: {},
       tags: [],
     });
+    const hydrationSymbols = [
+      "AAPL",
+      ...Array.from({ length: 13 }, (_, index) => `T${String(index + 1).padStart(2, "0")}`),
+    ];
+    for (const symbol of hydrationSymbols.slice(1)) {
+      await tickerRepository.createTicker({
+        ticker: symbol,
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: symbol,
+        portfolios: [],
+        watchlists: ["main"],
+        positions: [],
+        broker_contracts: [],
+        custom: {},
+        tags: [],
+      });
+    }
 
     const events: string[] = [];
+    const cachedTargetRequests: string[] = [];
+    const financialRefreshes: string[] = [];
 
     await initializeAppState({
       config: quoteOnlyConfig,
@@ -417,23 +437,26 @@ describe("initializeAppState", () => {
       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,
-          },
-        }]]),
+        getCachedFinancialsForTargets: (targets: Array<{ symbol: string }>) => {
+          cachedTargetRequests.push(...targets.map((target) => target.symbol));
+          return new Map(targets.map((target) => [target.symbol, {
+            annualStatements: [],
+            quarterlyStatements: [],
+            priceHistory: [],
+            quote: {
+              symbol: target.symbol,
+              price: 200,
+              currency: "USD",
+              change: 1,
+              changePercent: 0.5,
+              marketCap: 2_000_000_000,
+              lastUpdated: Date.now(),
+            },
+            fundamentals: {
+              trailingPE: 25,
+            },
+          }]));
+        },
       } as any,
       sessionSnapshot: {
         paneState: {
@@ -446,11 +469,11 @@ describe("initializeAppState", () => {
         activePanel: "left",
         statusBarVisible: true,
         openPaneIds: ["portfolio-list:main"],
-        hydrationTargets: [{
-          symbol: "AAPL",
+        hydrationTargets: hydrationSymbols.map((symbol) => ({
+          symbol,
           exchange: "NASDAQ",
           instrument: null,
-        }],
+        })),
         exchangeCurrencies: [],
         savedAt: Date.now(),
       },
@@ -458,13 +481,17 @@ describe("initializeAppState", () => {
       primeCachedFinancials: (entries) => {
         events.push(`prime:${entries.map((entry) => entry.ticker.metadata.ticker).join(",")}`);
       },
-      refreshTicker: () => {},
+      refreshTicker: (symbol) => { financialRefreshes.push(symbol); },
       refreshQuote: () => {},
       autoImportBrokerPositions: async () => {},
     });
 
-    expect(events).toContain("prime:AAPL");
-    expect(events.indexOf("prime:AAPL")).toBeLessThan(events.indexOf("SET_INITIALIZED"));
+    const primeEvent = events.find((event) => event.startsWith("prime:"));
+    expect(primeEvent).toContain("AAPL");
+    expect(primeEvent).toContain("T13");
+    expect(cachedTargetRequests).toContain("T13");
+    expect(financialRefreshes).not.toContain("T13");
+    expect(events.indexOf(primeEvent!)).toBeLessThan(events.indexOf("SET_INITIALIZED"));
 
     persistence.close();
   });

package/src/state/app-bootstrap.ts

@@ -216,26 +216,39 @@ function buildCachedFinancialTarget(ticker: TickerRecord): CachedFinancialsTarge
 async function resolveCachedFinancialPrimeEntries(
   refreshPlan: RefreshPlanEntry[],
   sessionSnapshot: AppSessionSnapshot | null | undefined,
+  tickerMap: Map<string, TickerRecord>,
   dataProvider: DataProvider,
 ): Promise<Array<{ ticker: TickerRecord; financials: TickerFinancials }>> {
   if (!dataProvider.getCachedFinancialsForTargets) return [];
 
-  const sessionTargetsBySymbol = new Map<string, CachedFinancialsTarget>();
+  const targetEntriesBySymbol = new Map<string, { ticker: TickerRecord; target: CachedFinancialsTarget }>();
   for (const target of sessionSnapshot?.hydrationTargets ?? []) {
-    sessionTargetsBySymbol.set(target.symbol.trim().toUpperCase(), target);
+    const symbol = target.symbol.trim().toUpperCase();
+    const ticker = tickerMap.get(symbol);
+    if (ticker) {
+      targetEntriesBySymbol.set(symbol, { ticker, target });
+    }
   }
 
-  const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
-  if (financialEntries.length === 0) return [];
+  for (const entry of refreshPlan.filter((entry) => entry.mode === "financials")) {
+    const symbol = entry.ticker.metadata.ticker.trim().toUpperCase();
+    if (!targetEntriesBySymbol.has(symbol)) {
+      targetEntriesBySymbol.set(symbol, {
+        ticker: entry.ticker,
+        target: buildCachedFinancialTarget(entry.ticker),
+      });
+    }
+  }
 
+  const targetEntries = [...targetEntriesBySymbol.values()];
+  if (targetEntries.length === 0) return [];
   const cachedFinancials = await dataProvider.getCachedFinancialsForTargets(
-    financialEntries.map(({ ticker }) => (
-      sessionTargetsBySymbol.get(ticker.metadata.ticker.trim().toUpperCase()) ?? buildCachedFinancialTarget(ticker)
-    )),
+    targetEntries.map((entry) => entry.target),
+    { includeStaleQuotes: true },
   );
   const primedEntries: Array<{ ticker: TickerRecord; financials: TickerFinancials }> = [];
 
-  for (const entry of financialEntries) {
+  for (const entry of targetEntries) {
     const cached = cachedFinancials.get(entry.ticker.metadata.ticker.trim().toUpperCase());
     if (cached) {
       primedEntries.push({ ticker: entry.ticker, financials: cached });
@@ -347,8 +360,11 @@ export async function initializeAppState({
   if (primeCachedFinancials) {
     const cachedPrimeEntries = await measurePerfAsync(
       "startup.resolve-cached-financial-prime",
-      () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, dataProvider),
-      { financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length },
+      () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, tickerMap, dataProvider),
+      {
+        financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length,
+        sessionHydrationTargetCount: sessionSnapshot?.hydrationTargets.length ?? 0,
+      },
     );
     if (cachedPrimeEntries.length > 0) {
       measurePerf("startup.prime-cached-financials", () => {

package/src/state/session-persistence.test.ts

@@ -24,7 +24,10 @@ function createTicker(symbol: string, exchange = "NASDAQ"): TickerRecord {
 describe("session persistence", () => {
   test("builds a working-set snapshot from runtime state", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
-    const tickers = new Map<string, TickerRecord>([["AAPL", createTicker("AAPL")]]);
+    const tickers = new Map<string, TickerRecord>([
+      ["AAPL", createTicker("AAPL")],
+      ["MSFT", createTicker("MSFT")],
+    ]);
     const financials = new Map<string, TickerFinancials>([["AAPL", {
       annualStatements: [],
       quarterlyStatements: [],
@@ -61,8 +64,7 @@ describe("session persistence", () => {
     });
 
     expect(snapshot.focusedPaneId).toBe("ticker-detail:main");
-    expect(snapshot.hydrationTargets).toHaveLength(1);
-    expect(snapshot.hydrationTargets[0]?.symbol).toBe("AAPL");
+    expect(snapshot.hydrationTargets.map((target) => target.symbol)).toEqual(["AAPL", "MSFT"]);
     expect(snapshot.exchangeCurrencies).toContain("JPY");
     expect(snapshot.paneState["portfolio-list:main"]).toEqual({
       cursorSymbol: "AAPL",

package/src/state/use-inline-tickers.ts

@@ -152,6 +152,9 @@ export function useInlineTickers(texts: readonly string[]): {
       return {
         symbol: ticker.metadata.ticker,
         exchange: ticker.metadata.exchange,
+        surface: "inline" as const,
+        visible: true,
+        weight: 40,
         context: instrument
           ? {
             brokerId: instrument.brokerId,

package/src/state/use-quote-streaming.ts

@@ -22,6 +22,7 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     ?? target.context?.instrument?.localSymbol
     ?? target.context?.instrument?.symbol
     ?? "";
+  const weight = Number.isFinite(target.weight) ? String(target.weight) : "";
   return [
     target.symbol,
     target.exchange ?? "",
@@ -29,6 +30,10 @@ export function buildQuoteStreamSubscriptionKey(target: QuoteSubscriptionTarget)
     target.context?.brokerInstanceId ?? "",
     contractKey,
     target.route ?? "auto",
+    target.surface ?? "",
+    target.visible ? "visible" : "",
+    target.selected ? "selected" : "",
+    weight,
   ].join("|");
 }
 
@@ -68,6 +73,12 @@ export function useQuoteStreaming(targets: QuoteSubscriptionTarget[]): void {
         brokerInstanceId: target.context?.brokerInstanceId,
         instrument: target.context?.instrument ?? null,
       },
+      priority: {
+        surface: target.surface,
+        visible: target.visible,
+        selected: target.selected,
+        weight: target.weight,
+      },
     })));
     return () => {
       quoteStreamLog.info("unsubscribe", {

package/src/types/data-provider.ts

@@ -90,6 +90,10 @@ export interface QuoteSubscriptionTarget {
   exchange?: string;
   context?: MarketDataRequestContext;
   route?: "auto" | "provider" | "broker";
+  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "screener" | "unknown";
+  visible?: boolean;
+  selected?: boolean;
+  weight?: number;
 }
 
 export interface QuoteBatchResult {
@@ -111,7 +115,7 @@ export interface AssetDataProvider {
   readonly cachePolicy?: CachePolicyMap;
 
   canProvide?(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<boolean> | boolean;
-  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean }): Map<string, TickerFinancials> | Promise<Map<string, TickerFinancials>>;
+  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean; includeStaleQuotes?: boolean }): Map<string, TickerFinancials> | Promise<Map<string, TickerFinancials>>;
   getQuotesBatch?(targets: QuoteSubscriptionTarget[], options?: { forceRefresh?: boolean }): Promise<QuoteBatchResult[]>;
   getTickerFinancialsBatch?(targets: CachedFinancialsTarget[], options?: { forceRefresh?: boolean }): Promise<TickerFinancialsBatchResult[]>;
   getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials>;

package/src/types/financials.ts

@@ -32,6 +32,7 @@ export interface Quote {
   volume?: number;
   name?: string;
   lastUpdated: number; // timestamp ms
+  receivedAt?: number; // local receipt timestamp ms for streamed/display freshness
   exchangeName?: string;
   fullExchangeName?: string;
   listingExchangeName?: string;

package/src/utils/api-client.test.ts

@@ -210,6 +210,126 @@ describe("apiClient auth cookies", () => {
 
     unsubscribe();
   });
+
+  test("opens an anonymous market websocket and sends quote priority hints", () => {
+    const sent: unknown[] = [];
+    const sockets: Array<{
+      url: string;
+      readyState: number;
+      onopen: ((event: unknown) => void) | null;
+      close: () => void;
+    }> = [];
+
+    class FakeWebSocket {
+      static OPEN = 1;
+      readyState = 1;
+      onopen: ((event: unknown) => void) | null = null;
+      onmessage: ((event: { data: string }) => void) | null = null;
+      onclose: ((event: unknown) => void) | null = null;
+      onerror: ((event: unknown) => void) | null = null;
+
+      constructor(readonly url: string) {
+        sockets.push(this);
+      }
+
+      send(payload: string): void {
+        sent.push(JSON.parse(payload));
+      }
+
+      close(): void {
+        this.readyState = 3;
+      }
+    }
+
+    globalThis.WebSocket = FakeWebSocket as any;
+
+    const unsubscribe = apiClient.subscribeQuotes([{
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      surface: "portfolio",
+      visible: true,
+      selected: true,
+      weight: 100,
+    }], () => {});
+    sockets[0]!.onopen?.({});
+
+    expect(sockets).toHaveLength(1);
+    expect(sockets[0]!.url).toBe("wss://api.gloom.sh/cloud/ws");
+    expect(sent).toContainEqual({
+      type: "market.subscribe",
+      symbols: [{
+        symbol: "AAPL",
+        exchange: "NASDAQ",
+        surface: "portfolio",
+        visible: true,
+        selected: true,
+        weight: 100,
+      }],
+    });
+
+    unsubscribe();
+  });
+
+  test("keeps an anonymous market websocket open after auth rejection", () => {
+    const seenPrices: number[] = [];
+    let closeCalls = 0;
+    const sockets: Array<{
+      readyState: number;
+      onopen: ((event: unknown) => void) | null;
+      onmessage: ((event: { data: string }) => void) | null;
+      close: () => void;
+    }> = [];
+
+    class FakeWebSocket {
+      static OPEN = 1;
+      readyState = 1;
+      onopen: ((event: unknown) => void) | null = null;
+      onmessage: ((event: { data: string }) => void) | null = null;
+      onclose: ((event: unknown) => void) | null = null;
+      onerror: ((event: unknown) => void) | null = null;
+
+      constructor(readonly _url: string) {
+        sockets.push(this);
+      }
+
+      send(): void {}
+
+      close(): void {
+        closeCalls += 1;
+        this.readyState = 3;
+      }
+    }
+
+    globalThis.WebSocket = FakeWebSocket as any;
+
+    const unsubscribe = apiClient.subscribeQuotes([{ symbol: "AAPL" }], (_target, quote) => {
+      seenPrices.push(quote.price);
+    });
+    sockets[0]!.onopen?.({});
+    sockets[0]!.onmessage?.({ data: JSON.stringify({ type: "auth.unverified" }) });
+    sockets[0]!.onmessage?.({
+      data: JSON.stringify({
+        type: "market.quote",
+        symbol: "AAPL",
+        exchange: "",
+        quote: {
+          symbol: "AAPL",
+          price: 123,
+          currency: "USD",
+          change: 0,
+          changePercent: 0,
+          lastUpdated: 1,
+          providerId: "gloomberb-cloud",
+          dataSource: "live",
+        },
+      }),
+    });
+
+    expect(closeCalls).toBe(0);
+    expect(seenPrices).toEqual([123]);
+
+    unsubscribe();
+  });
 });
 
 describe("apiClient chat timestamps", () => {