gloomberb 0.9.8 → 0.9.10

package/src/renderers/opentui/host.tsx

@@ -22,6 +22,7 @@ export function toKeyEventLike(event: {
   shift?: boolean;
   alt?: boolean;
   meta?: boolean;
+  option?: boolean;
   preventDefault?: () => void;
   stopPropagation?: () => void;
   defaultPrevented?: boolean;
@@ -37,9 +38,12 @@ export function toKeyEventLike(event: {
     sequence: event.sequence,
     ctrl: event.ctrl ?? false,
     shift: event.shift ?? false,
-    alt: event.alt ?? false,
-    meta: event.meta ?? event.super ?? false,
-    super: event.super ?? event.meta ?? false,
+    // OpenTUI follows terminal naming: `meta` is Alt/Option, while the
+    // kitty keyboard protocol exposes the Command/Windows modifier as
+    // `super`. Keep the shared input model aligned with browser semantics.
+    alt: event.alt === true || event.meta === true || event.option === true,
+    meta: event.super === true,
+    super: event.super === true,
     get defaultPrevented() {
       return event.defaultPrevented ?? false;
     },
@@ -101,6 +105,9 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
       await proc.exited;
     },
     async copyText(text) {
+      if (!text) return;
+      if (renderer.copyToClipboardOSC52(text)) return;
+      if (process.platform !== "darwin") return;
       const proc = Bun.spawn(["pbcopy"], {
         stdin: "pipe",
         stdout: "ignore",
@@ -111,6 +118,7 @@ export async function createOpenTuiHost(): Promise<OpenTuiHost> {
       await proc.exited;
     },
     async readText() {
+      if (process.platform !== "darwin") return "";
       const proc = Bun.spawn(["pbpaste"], {
         stdout: "pipe",
         stderr: "ignore",

package/src/renderers/opentui/input-host.tsx

@@ -1,4 +1,5 @@
 import { useLayoutEffect, useMemo, useRef, type ReactNode } from "react";
+import { useNativeRenderer } from "../../ui";
 import {
   InputHostProvider,
   shouldDeliverShortcut,
@@ -19,6 +20,7 @@ interface ShortcutEntry {
 let nextShortcutOrder = 1;
 
 export function OpenTuiInputHostProvider({ children }: { children: ReactNode }) {
+  const renderer = useNativeRenderer();
   const shortcutsRef = useRef<ShortcutEntry[]>([]);
   const dispatchShortcut = (event: KeyEventLike) => {
     const shortcuts = shortcutsRef.current;
@@ -34,7 +36,9 @@ export function OpenTuiInputHostProvider({ children }: { children: ReactNode })
   };
 
   useKeyboard((event) => {
-    dispatchShortcut(toKeyEventLike(event));
+    const shortcutEvent = toKeyEventLike(event);
+    shortcutEvent.targetEditable = renderer.currentFocusedEditor != null;
+    dispatchShortcut(shortcutEvent);
   });
 
   const host = useMemo<InputHost>(() => ({

package/src/sources/gloomberb-cloud/index.test.ts

@@ -450,78 +450,6 @@ describe("GloomberbCloudProvider", () => {
     expect(unsubscribeCalled).toBe(true);
   });
 
-  test("maps backend news stories without requiring verified market-data access", async () => {
-    type CloudNewsRequest = NonNullable<Parameters<typeof apiClient.getCloudNews>[0]>;
-    let verifyCalled = false;
-    const requestArgs: { current: CloudNewsRequest | null } = { current: null };
-    apiClient.ensureVerifiedSession = async () => {
-      verifyCalled = true;
-      return verifiedUser;
-    };
-    apiClient.getCloudNews = async (params = {}) => {
-      requestArgs.current = params;
-      return {
-        items: [{
-          id: "story-1",
-          headline: "Apple raises guidance",
-          summary: "Apple lifted its outlook after stronger iPhone demand.",
-          topic: "guidance",
-          topics: ["guidance"],
-          category: "guidance",
-          sentiment: "positive",
-          sectors: ["information_technology"],
-          firstPublishedAt: "2026-04-01T10:00:00.000Z",
-          lastPublishedAt: "2026-04-01T10:05:00.000Z",
-          firstSeenAt: "2026-04-01T10:00:10.000Z",
-          lastSeenAt: "2026-04-01T10:05:10.000Z",
-          primaryUrl: "https://example.com/aapl-guidance",
-          primarySource: "example-wire",
-          scores: {
-            importance: 91,
-            urgency: 74,
-            marketImpact: 88,
-            novelty: 86,
-            confidence: 95,
-          },
-          flags: {
-            breaking: true,
-            developing: false,
-            stale: false,
-          },
-          variantCount: 1,
-          sourceCount: 1,
-          sources: ["example-wire"],
-          entities: [],
-          tickerLinks: [{
-            symbol: "AAPL",
-            exchange: "XNAS",
-            canonicalTicker: "AAPL:XNAS",
-            relationType: "direct",
-            displayTier: "primary",
-            confidence: 0.98,
-            relevanceScore: 95,
-            impactScore: 93,
-            sentiment: "positive",
-          }],
-        }],
-        nextCursor: null,
-      };
-    };
-
-    const provider = new GloomberbCloudProvider();
-    const news = await provider.getNews("AAPL", 10, "NASDAQ");
-
-    expect(verifyCalled).toBe(false);
-    expect(requestArgs.current).toEqual({ feed: "ticker", ticker: "AAPL", exchange: "XNAS", tickerTier: "primary", limit: 10 });
-    expect(news).toEqual([{
-      title: "Apple raises guidance",
-      url: "https://example.com/aapl-guidance",
-      source: "example-wire",
-      publishedAt: new Date("2026-04-01T10:05:00.000Z"),
-      summary: "Apple lifted its outlook after stronger iPhone demand.",
-    }]);
-  });
-
   test("maps news ticker labels from validated story links only", async () => {
     apiClient.getCloudNews = async () => ({
       items: [{

package/src/sources/gloomberb-cloud/index.ts

@@ -9,11 +9,9 @@ import type {
   AssetDataProvider,
   CachedFinancialsTarget,
   MarketDataRequestContext,
-  NewsItem,
   QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
-  SecFilingItem,
   TickerFinancialsBatchResult,
 } from "../../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
@@ -27,12 +25,11 @@ import {
 } from "../../api-client";
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
-import { canonicalTickerKey, publicExchange } from "../../utils/exchanges";
+import { canonicalTickerKey } from "../../utils/exchanges";
 import { createProviderMiss } from "../provider-errors";
 import {
   cloudNewsParams,
   mapCloudNewsArticle,
-  mapCloudNewsItem,
 } from "./news";
 import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
@@ -237,20 +234,6 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
-  async getNews(ticker: string, count?: number, exchange?: string, _context?: MarketDataRequestContext): Promise<NewsItem[]> {
-    const response = await withCloudFallback(
-      () => apiClient.getCloudNews({
-        feed: "ticker",
-        ticker,
-        exchange: exchange ? publicExchange(exchange) : undefined,
-        tickerTier: "primary",
-        limit: count,
-      }),
-      `Cloud news is unavailable for ${ticker}`,
-    );
-    return response.items.map(mapCloudNewsItem);
-  }
-
   async getHolders(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<HolderData> {
     await requireVerifiedSession();
     return withCloudFallback(async () => {
@@ -275,18 +258,6 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     }, `Cloud corporate actions are unavailable for ${ticker}`);
   }
 
-  async getSecFilings(_ticker: string, _count?: number, _exchange?: string, _context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
-    throw createProviderMiss("Cloud SEC filings are not available");
-  }
-
-  async getSecFilingDocuments(_filing: SecFilingItem) {
-    throw createProviderMiss("Cloud filing documents are not available");
-  }
-
-  async getSecFilingContent(_filing: SecFilingItem): Promise<string | null> {
-    throw createProviderMiss("Cloud filing content is not available");
-  }
-
   async getArticleSummary(_url: string): Promise<string | null> {
     throw createProviderMiss("Cloud article summaries are not available");
   }

package/src/sources/gloomberb-cloud/news.ts

@@ -1,5 +1,4 @@
 import { collectNewsDisplayTickers } from "../../news/ticker-symbols";
-import type { NewsItem } from "../../types/data-provider";
 import type { NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
 import type {
   CloudNewsPayload,
@@ -90,17 +89,6 @@ export function mapCloudNewsArticle(
   };
 }
 
-export function mapCloudNewsItem(item: CloudNewsPayload): NewsItem {
-  const article = mapCloudNewsArticle(item);
-  return {
-    title: article.title,
-    url: article.url,
-    source: article.source,
-    publishedAt: article.publishedAt,
-    summary: article.summary,
-  };
-}
-
 export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
   const feed = query.feed ?? (query.scope === "ticker" ? "ticker" : "latest");
   return {

package/src/sources/provider-router/financial-routes.ts

@@ -43,6 +43,19 @@ export interface ProviderRouterFinancialRouteDeps extends Pick<
   primaryRoutes: ProviderRouterPrimaryRoutes;
 }
 
+function withoutSessionState(quote: Quote): Quote {
+  const fallback = { ...quote };
+  delete fallback.marketState;
+  delete fallback.sessionConfidence;
+  delete fallback.preMarketPrice;
+  delete fallback.preMarketChange;
+  delete fallback.preMarketChangePercent;
+  delete fallback.postMarketPrice;
+  delete fallback.postMarketChange;
+  delete fallback.postMarketChangePercent;
+  return fallback;
+}
+
 export class ProviderRouterFinancialRoutes {
   constructor(private readonly deps: ProviderRouterFinancialRouteDeps) {}
 
@@ -169,16 +182,21 @@ export class ProviderRouterFinancialRoutes {
     exchange?: string,
     context?: MarketDataRequestContext,
   ): Promise<Quote | null> {
-    const cached = this.readCachedProviderQuote(ticker, exchange, context);
+    const cached = context?.cacheMode === "refresh"
+      ? null
+      : this.readCachedProviderQuote(ticker, exchange, context);
     if (cached) return cached;
+    const staleFallback = this.readCachedProviderQuote(ticker, exchange, context, true);
     const providerQuote = await this.deps.primaryRoutes.fetchProviderQuote(ticker, exchange, context);
-    return providerQuote?.value ?? null;
+    if (providerQuote) return providerQuote.value;
+    return staleFallback ? withoutSessionState(staleFallback) : null;
   }
 
   private readCachedProviderQuote(
     ticker: string,
     exchange?: string,
     context?: MarketDataRequestContext,
+    includeStale = false,
   ): Quote | null {
     const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
     const entityKeys = [...new Set([entityKey, normalizeTicker(ticker)])];
@@ -186,7 +204,11 @@ export class ProviderRouterFinancialRoutes {
     const sourceKeys = this.deps.getProviderSourceKeys();
     for (const candidateEntityKey of entityKeys) {
       const record = selectCachedResource<Quote>(this.deps.resources, "quote", candidateEntityKey, variantKeys, sourceKeys, false);
-      if (record && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(record.value, exchange))) {
+      if (
+        record
+        && (includeStale || !record.stale)
+        && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(record.value, exchange))
+      ) {
         return record.value;
       }
     }

package/src/sources/provider-router/index.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { CloudApiRequestTransport } from "../../api-client/request";
 import { AppPersistence } from "../../data/app-persistence";
 import { AssetDataRouter } from "./index";
 import { assetDataProvider } from "../../capabilities";
@@ -26,6 +27,59 @@ afterEach(() => {
 });
 
 describe("AssetDataRouter", () => {
+  test("falls through to Yahoo quotes and history when Cloud market requests never settle", async () => {
+    const cloudCalls = { quote: 0, history: 0 };
+    const yahooCalls = { quote: 0, history: 0 };
+    const cloudTransport = new CloudApiRequestTransport({
+      marketRequestTimeoutMs: 10,
+      fetchTransport: async () => new Promise<Response>(() => {}),
+    });
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "gloomberb-cloud",
+      name: "Cloud",
+      priority: 100,
+      async getQuote() {
+        cloudCalls.quote += 1;
+        await cloudTransport.request("/market/quote?symbol=AAPL");
+        throw new Error("unreachable");
+      },
+      async getPriceHistory() {
+        cloudCalls.history += 1;
+        await cloudTransport.request("/market/history?symbol=AAPL&range=1Y");
+        throw new Error("unreachable");
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      async getQuote() {
+        yahooCalls.quote += 1;
+        return makeQuote({ providerId: "yahoo", price: 212.5 });
+      },
+      async getPriceHistory() {
+        yahooCalls.history += 1;
+        return [
+          { date: new Date("2026-07-10T00:00:00Z"), close: 210 },
+          { date: new Date("2026-07-11T00:00:00Z"), close: 212.5 },
+        ];
+      },
+    };
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+    console.error = () => {};
+
+    const quote = await router.getQuote("AAPL", "NASDAQ");
+    const history = await router.getPriceHistory("AAPL", "NASDAQ", "1Y");
+
+    expect(quote.providerId).toBe("yahoo");
+    expect(quote.price).toBe(212.5);
+    expect(history.map((point) => point.close)).toEqual([210, 212.5]);
+    expect(cloudCalls).toEqual({ quote: 1, history: 1 });
+    expect(yahooCalls).toEqual({ quote: 1, history: 1 });
+  });
+
   test("serves USD exchange rate locally without provider revalidation", async () => {
     let providerCalls = 0;
     const router = new AssetDataRouter({
@@ -367,6 +421,119 @@ describe("AssetDataRouter", () => {
     expect(quote.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
   });
 
+  test("refreshes broker option session references across the market close", async () => {
+    const dbPath = createTempDbPath("option-session-transition");
+    const persistence = new AppPersistence(dbPath);
+    const optionSymbol = "IBIT  281215C00030000";
+    const entityKey = `contract:${optionSymbol}`;
+    const providerSourceKey = "provider:yahoo";
+    const cacheKey = {
+      namespace: "market",
+      kind: "quote",
+      entityKey,
+      variantKey: "",
+      sourceKey: providerSourceKey,
+    };
+    const regularReference = makeQuote({
+      symbol: optionSymbol,
+      providerId: "yahoo",
+      price: 15.775,
+      change: 0.29,
+      changePercent: 1.87,
+      previousClose: 15.485,
+      listingExchangeName: "OPTIONS",
+      marketState: "REGULAR",
+      sessionConfidence: "derived",
+    });
+    let providerCalls = 0;
+    let providerAvailable = true;
+    const provider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getQuote() {
+        providerCalls += 1;
+        if (!providerAvailable) throw new Error("temporary provider outage");
+        return {
+          ...regularReference,
+          marketState: "CLOSED",
+          lastUpdated: Date.now(),
+        };
+      },
+    };
+    const broker: BrokerAdapter = {
+      id: "ibkr",
+      name: "IBKR",
+      configSchema: [],
+      async validate() {
+        return true;
+      },
+      async importPositions() {
+        return [];
+      },
+      async getQuote() {
+        return {
+          ...regularReference,
+          providerId: "ibkr",
+          previousClose: 99,
+          marketState: undefined,
+          sessionConfidence: "unknown",
+          dataSource: "live",
+          lastUpdated: Date.now(),
+        };
+      },
+    };
+
+    try {
+      persistence.resources.set(cacheKey, regularReference, {
+        cachePolicy: { staleMs: 60_000, expireMs: 24 * 60 * 60_000 },
+        fetchedAt: Date.now() - 2 * 60_000,
+      });
+      const router = new AssetDataRouter(provider, [], persistence.resources);
+      attachTestRegistry(router, { brokers: [["ibkr", broker]] });
+      setBrokerInstances(router, [brokerInstance()]);
+      const context = {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        instrument: {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-work",
+          symbol: "IBIT",
+          localSymbol: optionSymbol,
+          secType: "OPT",
+        },
+      } as const;
+
+      const staleTransition = await router.getQuote(optionSymbol, "", context);
+      expect(staleTransition.marketState).toBe("CLOSED");
+      expect(providerCalls).toBe(1);
+
+      persistence.resources.set(cacheKey, regularReference, {
+        cachePolicy: { staleMs: 60_000, expireMs: 24 * 60 * 60_000 },
+        fetchedAt: Date.now(),
+      });
+      const forcedTransition = await router.getQuote(optionSymbol, "", {
+        ...context,
+        cacheMode: "refresh",
+      });
+      expect(forcedTransition.marketState).toBe("CLOSED");
+      expect(providerCalls).toBe(2);
+
+      providerAvailable = false;
+      persistence.resources.set(cacheKey, regularReference, {
+        cachePolicy: { staleMs: 60_000, expireMs: 24 * 60 * 60_000 },
+        fetchedAt: Date.now() - 2 * 60_000,
+      });
+      const outageFallback = await router.getQuote(optionSymbol, "", context);
+      expect(outageFallback.previousClose).toBe(15.485);
+      expect(outageFallback.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+      expect(outageFallback.marketState).toBeUndefined();
+      expect(providerCalls).toBe(3);
+    } finally {
+      persistence.close();
+    }
+  });
+
   test("prefers broker options chains for broker-context targets", async () => {
     const chain = {
       underlyingSymbol: "AAPL",

package/src/sources/provider-router/search.ts

@@ -4,6 +4,7 @@ import type { BrokerCandidate } from "./brokers";
 import { shouldLogProviderError } from "../provider-errors";
 
 const SEARCH_CACHE_TTL_MS = 30_000;
+const SEARCH_CACHE_MAX_ENTRIES = 100;
 
 const SEARCH_PROVIDER_TIMEOUT_MS = 5_000;
 
@@ -88,6 +89,7 @@ export class ProviderRouterSearchRoutes {
     const cacheKey = buildSearchCacheKey(query, context);
     const cached = this.searchCache.get(cacheKey);
     if (cached && cached.expiresAt > Date.now()) return cached.results;
+    if (cached) this.searchCache.delete(cacheKey);
     const inFlight = this.searchInFlight.get(cacheKey);
     if (inFlight) return inFlight;
 
@@ -111,6 +113,9 @@ export class ProviderRouterSearchRoutes {
         expiresAt: Date.now() + ttl,
         results,
       });
+      if (this.searchCache.size > SEARCH_CACHE_MAX_ENTRIES) {
+        this.searchCache.delete(this.searchCache.keys().next().value!);
+      }
     };
     const push = (items: InstrumentSearchResult[]) => {
       mergeSearchResults(results, resultIndexByKey, items, context);

package/src/sources/provider-router/supplemental.ts

@@ -57,7 +57,7 @@ export class ProviderRouterSupplementalRoutes {
 
     const result = await firstProviderResult(this.deps, async (provider) => {
       const rate = await provider.getExchangeRate(normalizedCurrency);
-      return { provider, rate };
+      return Number.isFinite(rate) && rate > 0 ? { provider, rate } : null;
     });
     if (!result) {
       throw new Error(`No exchange rate provider available for ${normalizedCurrency}`);
@@ -164,7 +164,8 @@ export class ProviderRouterSupplementalRoutes {
     if (normalizedCurrency === "USD") return 1;
     const entityKey = `${normalizedCurrency}/USD`;
     const cached = selectCachedResource<{ rate: number }>(this.deps.resources, "exchange-rate", entityKey, [""], this.deps.getProviderSourceKeys(), allowExpired);
-    return cached?.value.rate ?? null;
+    const rate = cached?.value.rate;
+    return typeof rate === "number" && Number.isFinite(rate) && rate > 0 ? rate : null;
   }
 
   private cacheExchangeRate(currency: string, rate: number, provider: DataProvider): void {
@@ -341,7 +342,7 @@ export class ProviderRouterSupplementalRoutes {
 
     const result = await firstProviderResult(this.deps, async (provider) => {
       const rate = await provider.getExchangeRate(normalizedCurrency);
-      return { provider, rate };
+      return Number.isFinite(rate) && rate > 0 ? { provider, rate } : null;
     });
     if (!result) return;
     this.cacheExchangeRate(normalizedCurrency, result.value.rate, result.value.provider);

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

@@ -33,7 +33,11 @@ type YahooChartFetcher = (
   symbol: string,
   range: string,
   interval: ManualChartResolution,
-) => Promise<ChartResult>;
+) => Promise<{
+  meta: NonNullable<ChartResult["meta"]>;
+  history: PricePoint[];
+  events?: ChartResult["events"];
+}>;
 
 export function getYahooChartResolutionSupport(): ChartResolutionSupport[] {
   return YAHOO_RESOLUTION_SUPPORT;