gloomberb 0.7.0 → 0.7.1

package/src/utils/api-client.ts

@@ -12,10 +12,12 @@ import type {
 import type { InstrumentSearchResult } from "../types/instrument";
 import { debugLog } from "./debug-log";
 import { canonicalExchange, normalizeSymbol, publicTickerKey } from "./exchanges";
+import { httpFetch } from "./http-transport";
 import { normalizeTimestamp } from "./timestamp";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
 const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
+const QUOTE_SUBSCRIPTION_FLUSH_MS = 25;
 const cloudApiLog = debugLog.createLogger("cloud-api");
 const HARD_SESSION_INVALID_PATTERNS = [
   /\b(user|account)\b.*\b(not found|deleted|removed|disabled|deactivated|suspended)\b/i,
@@ -26,10 +28,10 @@ const HARD_SESSION_INVALID_PATTERNS = [
 type CloudApiResponse = Pick<Response, "ok" | "status" | "headers" | "text">;
 type CloudApiFetchTransport = (url: string, init?: RequestInit) => Promise<CloudApiResponse>;
 
-let cloudApiFetchTransport: CloudApiFetchTransport = (url, init) => fetch(url, init);
+let cloudApiFetchTransport: CloudApiFetchTransport = httpFetch;
 
 export function setCloudApiFetchTransport(transport: CloudApiFetchTransport | null): void {
-  cloudApiFetchTransport = transport ?? ((url, init) => fetch(url, init));
+  cloudApiFetchTransport = transport ?? httpFetch;
 }
 
 function getCloudApiBaseUrl(): string {
@@ -54,7 +56,6 @@ export interface ChatMessage {
 export interface ChatChannel {
   id: string;
   name: string;
-  description: string | null;
   created_at: string;
 }
 
@@ -306,6 +307,23 @@ export interface CloudMarketResponse<T> {
   };
 }
 
+export interface CloudMarketBatchTarget {
+  symbol: string;
+  exchange?: string;
+}
+
+export interface CloudMarketBatchItem<T> {
+  symbol: string;
+  exchange: string;
+  status: CloudMarketStatus;
+  data: T | null;
+  reasonCode?: string;
+}
+
+export interface CloudMarketBatchPayload<T> {
+  items: Array<CloudMarketBatchItem<T>>;
+}
+
 export interface CloudVerificationResponse {
   sent: boolean;
   email?: string;
@@ -392,6 +410,9 @@ class GloomApiClient {
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
   private readonly quoteListeners = new Map<string, Set<QuoteListener>>();
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
+  private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
+  private readonly pendingQuoteUnsubscribes = new Map<string, QuoteStreamTarget>();
+  private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor() {
     this.baseUrl = getCloudApiBaseUrl();
@@ -467,7 +488,7 @@ class GloomApiClient {
     throw new Error(message);
   }
 
-  private extractSessionCookie(res: Response): void {
+  private extractSessionCookie(res: CloudApiResponse): void {
     const setCookie = res.headers.getSetCookie?.() ?? [];
     const fallbackHeader = res.headers.get("set-cookie");
     if (fallbackHeader) {
@@ -654,6 +675,62 @@ class GloomApiClient {
     }
   }
 
+  private scheduleQuoteSubscriptionFlush(): void {
+    if (this.quoteSubscriptionFlushTimer) return;
+    this.quoteSubscriptionFlushTimer = setTimeout(() => {
+      this.quoteSubscriptionFlushTimer = null;
+      this.flushQueuedQuoteSubscriptions();
+    }, QUOTE_SUBSCRIPTION_FLUSH_MS);
+  }
+
+  private queueQuoteSubscribes(targets: QuoteStreamTarget[]): void {
+    for (const target of targets) {
+      const key = marketKey(target.symbol, target.exchange);
+      this.pendingQuoteUnsubscribes.delete(key);
+      this.pendingQuoteSubscribes.set(key, target);
+    }
+    this.scheduleQuoteSubscriptionFlush();
+  }
+
+  private queueQuoteUnsubscribes(targets: QuoteStreamTarget[]): void {
+    for (const target of targets) {
+      const key = marketKey(target.symbol, target.exchange);
+      if (this.pendingQuoteSubscribes.delete(key)) continue;
+      this.pendingQuoteUnsubscribes.set(key, target);
+    }
+    this.scheduleQuoteSubscriptionFlush();
+  }
+
+  private flushQueuedQuoteSubscriptions(): void {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      this.pendingQuoteSubscribes.clear();
+      this.pendingQuoteUnsubscribes.clear();
+      return;
+    }
+    const subscribes = [...this.pendingQuoteSubscribes.values()];
+    const unsubscribes = [...this.pendingQuoteUnsubscribes.values()];
+    this.pendingQuoteSubscribes.clear();
+    this.pendingQuoteUnsubscribes.clear();
+    if (subscribes.length > 0) {
+      this.sendSocketMessage({
+        type: "market.subscribe",
+        symbols: subscribes.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange ?? "",
+        })),
+      });
+    }
+    if (unsubscribes.length > 0) {
+      this.sendSocketMessage({
+        type: "market.unsubscribe",
+        symbols: unsubscribes.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange ?? "",
+        })),
+      });
+    }
+  }
+
   private async handleSocketMessage(raw: string): Promise<void> {
     let parsed: any;
     try {
@@ -879,13 +956,7 @@ class GloomApiClient {
         count: newSubscriptions.length,
         symbols: newSubscriptions.map((target) => marketKey(target.symbol, target.exchange)),
       });
-      this.sendSocketMessage({
-        type: "market.subscribe",
-        symbols: newSubscriptions.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
-      });
+      this.queueQuoteSubscribes(newSubscriptions);
     }
 
     return () => {
@@ -911,13 +982,7 @@ class GloomApiClient {
           count: removedTargets.length,
           symbols: removedTargets.map((target) => marketKey(target.symbol, target.exchange)),
         });
-        this.sendSocketMessage({
-          type: "market.unsubscribe",
-          symbols: removedTargets.map((target) => ({
-            symbol: target.symbol,
-            exchange: target.exchange ?? "",
-          })),
-        });
+        this.queueQuoteUnsubscribes(removedTargets);
       }
 
       if (!this.shouldKeepSocketOpen()) {
@@ -934,6 +999,12 @@ class GloomApiClient {
     this.channelListeners.clear();
     this.quoteListeners.clear();
     this.quoteTargets.clear();
+    this.pendingQuoteSubscribes.clear();
+    this.pendingQuoteUnsubscribes.clear();
+    if (this.quoteSubscriptionFlushTimer) {
+      clearTimeout(this.quoteSubscriptionFlushTimer);
+      this.quoteSubscriptionFlushTimer = null;
+    }
     this.reconnectDelayMs = 1000;
     this.teardownSocket();
   }
@@ -953,6 +1024,16 @@ class GloomApiClient {
     return this.request<CloudMarketResponse<CloudQuotePayload>>(`/market/quote?${params.toString()}`);
   }
 
+  async getCloudQuotesBatch(
+    targets: CloudMarketBatchTarget[],
+    mode: "cache-first" | "refresh" = "cache-first",
+  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>> {
+    return this.request<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>>("/market/quotes/batch", {
+      method: "POST",
+      body: JSON.stringify({ targets, mode }),
+    });
+  }
+
   async getCloudProfile(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCompanyProfile>> {
     const params = new URLSearchParams({ symbol });
     if (exchange) params.set("exchange", exchange);
@@ -965,6 +1046,22 @@ class GloomApiClient {
     return this.request<CloudMarketResponse<CloudFundamentals>>(`/market/fundamentals?${params.toString()}`);
   }
 
+  async getCloudFinancials(symbol: string, exchange?: string): Promise<CloudMarketResponse<TickerFinancials>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    return this.request<CloudMarketResponse<TickerFinancials>>(`/market/financials?${params.toString()}`);
+  }
+
+  async getCloudFinancialsBatch(
+    targets: CloudMarketBatchTarget[],
+    mode: "cache-first" | "refresh" = "cache-first",
+  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<TickerFinancials>>> {
+    return this.request<CloudMarketResponse<CloudMarketBatchPayload<TickerFinancials>>>("/market/financials/batch", {
+      method: "POST",
+      body: JSON.stringify({ targets, mode }),
+    });
+  }
+
   async getCloudHolders(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudHoldersPayload>> {
     const params = new URLSearchParams({ symbol });
     if (exchange) params.set("exchange", exchange);
@@ -1093,6 +1190,10 @@ class GloomApiClient {
     return this.request<CloudNewsListResponse>(`/news${query ? `?${query}` : ""}`);
   }
 
+  async getCloudNewsStory(storyId: string): Promise<CloudNewsPayload> {
+    return this.request<CloudNewsPayload>(`/news/${encodeURIComponent(storyId)}`);
+  }
+
   async getCloudTickerTweets(params: {
     ticker: string;
     limit?: number;

package/src/utils/double-escape-close.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createDoubleEscapeCloseState,
+  recordDoubleEscapeClose,
+  resetDoubleEscapeClose,
+} from "./double-escape-close";
+
+describe("double escape close detector", () => {
+  test("matches a second escape for the same target inside the threshold", () => {
+    const state = createDoubleEscapeCloseState();
+
+    expect(recordDoubleEscapeClose(state, "pane:a", 1000)).toBe(false);
+    expect(recordDoubleEscapeClose(state, "pane:a", 1200)).toBe(true);
+    expect(state.targetId).toBe(null);
+  });
+
+  test("requires the same target and a recent first escape", () => {
+    const state = createDoubleEscapeCloseState();
+
+    expect(recordDoubleEscapeClose(state, "pane:a", 1000)).toBe(false);
+    expect(recordDoubleEscapeClose(state, "pane:b", 1100)).toBe(false);
+    expect(recordDoubleEscapeClose(state, "pane:b", 2000)).toBe(false);
+    expect(recordDoubleEscapeClose(state, "pane:b", 2100)).toBe(true);
+  });
+
+  test("can be reset by non-escape input", () => {
+    const state = createDoubleEscapeCloseState();
+
+    expect(recordDoubleEscapeClose(state, "pane:a", 1000)).toBe(false);
+    resetDoubleEscapeClose(state);
+    expect(recordDoubleEscapeClose(state, "pane:a", 1100)).toBe(false);
+  });
+});

package/src/utils/double-escape-close.ts

@@ -0,0 +1,40 @@
+export const DOUBLE_ESCAPE_CLOSE_MS = 650;
+
+export interface DoubleEscapeCloseState {
+  lastAt: number;
+  targetId: string | null;
+}
+
+export function createDoubleEscapeCloseState(): DoubleEscapeCloseState {
+  return {
+    lastAt: 0,
+    targetId: null,
+  };
+}
+
+export function resetDoubleEscapeClose(state: DoubleEscapeCloseState) {
+  state.lastAt = 0;
+  state.targetId = null;
+}
+
+export function recordDoubleEscapeClose(
+  state: DoubleEscapeCloseState,
+  targetId: string | null | undefined,
+  now: number,
+  thresholdMs = DOUBLE_ESCAPE_CLOSE_MS,
+): boolean {
+  if (!targetId) {
+    resetDoubleEscapeClose(state);
+    return false;
+  }
+
+  const matched = state.targetId === targetId && now - state.lastAt <= thresholdMs;
+  if (matched) {
+    resetDoubleEscapeClose(state);
+    return true;
+  }
+
+  state.targetId = targetId;
+  state.lastAt = now;
+  return false;
+}

package/src/utils/throttled-fetch.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, test, mock, beforeEach, afterAll } from "bun:test";
 import { createThrottledFetch } from "./throttled-fetch";
+import { setHttpFetchTransport } from "./http-transport";
 
 // Mock global fetch
 const originalFetch = globalThis.fetch;
 let fetchMock: ReturnType<typeof mock>;
 
 beforeEach(() => {
+  setHttpFetchTransport(null);
   fetchMock = mock(() => Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 })));
   globalThis.fetch = fetchMock as any;
 });
@@ -156,9 +158,29 @@ describe("createThrottledFetch", () => {
     expect(transportMock).toHaveBeenCalledTimes(1);
     expect(fetchMock).not.toHaveBeenCalled();
   });
+
+  test("uses the shared HTTP transport by default", async () => {
+    const transportMock = mock((url: string, init?: RequestInit) => {
+      expect(url).toBe("https://api.example.com/shared");
+      expect((init?.headers as Record<string, string>)["X-Shared"]).toBe("1");
+      return Promise.resolve(new Response("shared", { status: 203 }));
+    });
+    setHttpFetchTransport(transportMock);
+
+    const client = createThrottledFetch({
+      defaultHeaders: { "X-Shared": "1" },
+    });
+    const resp = await client.fetch("https://api.example.com/shared");
+
+    expect(resp.status).toBe(203);
+    expect(await resp.text()).toBe("shared");
+    expect(transportMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
 });
 
 // Restore
 afterAll(() => {
+  setHttpFetchTransport(null);
   globalThis.fetch = originalFetch;
 });

package/src/utils/throttled-fetch.ts

@@ -7,6 +7,8 @@
  *   const data = await client.fetch("https://api.example.com/data");
  */
 
+import { httpFetch } from "./http-transport";
+
 const DEFAULT_REQUESTS_PER_MINUTE = 30;
 const DEFAULT_MAX_RETRIES = 2;
 const DEFAULT_TIMEOUT_MS = 10_000;
@@ -50,7 +52,7 @@ export function createThrottledFetch(
   const defaultHeaders = options.defaultHeaders ?? {};
   const dedupeGetRequests = options.dedupeGetRequests ?? true;
   const fetchTransport =
-    options.transport ?? ((url: string, init?: RequestInit) => globalThis.fetch(url, init));
+    options.transport ?? httpFetch;
 
   // Sliding window: track timestamps of recent requests per host
   const hostTimestamps = new Map<string, number[]>();

package/src/utils/ticker-search.ts

@@ -3,12 +3,14 @@ import type { InstrumentSearchResult } from "../types/instrument";
 import type { TickerRecord } from "../types/ticker";
 import type { TickerMetadata } from "../types/ticker";
 import type { TickerRepository } from "../data/ticker-repository";
+import { parseOptionSymbol } from "./options";
 
 export type TickerSearchInstrumentClass = "equity" | "fund" | "derivative" | "other";
 export type TickerSearchCategory = "Saved" | "Primary Listing" | "Other Listings" | "Funds & Derivatives";
 
 const FUND_TYPES = new Set(["ETF", "ETN", "ETP", "FUND", "MUTUALFUND", "CEF", "CLOSEDEND"]);
 const DERIVATIVE_TYPES = new Set(["OPT", "OPTION", "OPTIONS", "FUT", "FUTURE", "FUTURES", "WARRANT", "WARRANTS", "RIGHT", "RIGHTS"]);
+const OPTION_TYPES = new Set(["OPT", "OPTION", "OPTIONS"]);
 const EQUITY_TYPES = new Set(["STK", "STOCK", "EQUITY", "COMMONSTOCK", "COMMON STOCK", "ADR", "ORDINARYSHARES", "ORDINARY SHARES"]);
 
 const EXCHANGE_HINT_ALIASES: Record<string, string[]> = {
@@ -90,6 +92,10 @@ interface SearchQueryIntent {
   assetPreference: TickerSearchInstrumentClass | null;
 }
 
+interface TickerSearchCandidateOptions {
+  includeOptionContracts?: boolean;
+}
+
 export function normalizeTickerInput(activeTicker: string | null, arg?: string): string | null {
   const explicitTicker = arg?.trim().toUpperCase();
   if (explicitTicker) return explicitTicker;
@@ -99,11 +105,13 @@ export function normalizeTickerInput(activeTicker: string | null, arg?: string):
 export function createLocalTickerSearchCandidates(
   tickers: Iterable<TickerRecord>,
   providerHints: ReadonlyMap<string, InstrumentSearchResult> = new Map(),
+  options: TickerSearchCandidateOptions = {},
 ): TickerSearchCandidate[] {
-  return Array.from(tickers).map((ticker) => {
+  return Array.from(tickers).flatMap((ticker) => {
+    if (options.includeOptionContracts === false && isOptionTickerRecord(ticker)) return [];
     const symbol = normalizeTickerSymbol(ticker.metadata.ticker);
     const hint = providerHints.get(symbol);
-    return {
+    return [{
       id: `goto:${ticker.metadata.ticker}`,
       label: ticker.metadata.ticker,
       symbol,
@@ -118,18 +126,20 @@ export function createLocalTickerSearchCandidates(
       searchAliases: buildSymbolAliases(symbol),
       ticker,
       result: hint,
-    };
+    }];
   });
 }
 
 export function createProviderTickerSearchCandidates(
   searchResults: InstrumentSearchResult[],
   localTickers: ReadonlyMap<string, TickerRecord>,
+  options: TickerSearchCandidateOptions = {},
 ): TickerSearchCandidate[] {
-  return searchResults.map((result) => {
+  return searchResults.flatMap((result) => {
+    if (options.includeOptionContracts === false && isOptionSearchResult(result)) return [];
     const symbol = getSearchResultSymbol(result);
     const saved = localTickers.has(symbol);
-    return {
+    return [{
       id: `search:${result.symbol}`,
       label: symbol,
       symbol,
@@ -143,7 +153,7 @@ export function createProviderTickerSearchCandidates(
       instrumentClass: classifyInstrumentKind(result.brokerContract?.secType || result.type),
       searchAliases: buildSearchResultAliases(result),
       result,
-    };
+    }];
   });
 }
 
@@ -154,6 +164,7 @@ export async function searchTickerCandidates({
   searchContext,
   localLimit = 6,
   totalLimit = 8,
+  includeOptionContracts = true,
 }: {
   query: string;
   tickers: ReadonlyMap<string, TickerRecord>;
@@ -161,6 +172,7 @@ export async function searchTickerCandidates({
   searchContext?: SearchRequestContext;
   localLimit?: number;
   totalLimit?: number;
+  includeOptionContracts?: boolean;
 }): Promise<TickerSearchCandidate[]> {
   return buildTickerSearchCandidates({
     query,
@@ -168,6 +180,7 @@ export async function searchTickerCandidates({
     providerResults: await searchProviderResults(dataProvider, query, searchContext),
     localLimit,
     totalLimit,
+    includeOptionContracts,
   });
 }
 
@@ -177,19 +190,25 @@ export function buildTickerSearchCandidates({
   providerResults,
   localLimit = 6,
   totalLimit = 8,
+  includeOptionContracts = true,
 }: {
   query: string;
   tickers: ReadonlyMap<string, TickerRecord>;
   providerResults: InstrumentSearchResult[];
   localLimit?: number;
   totalLimit?: number;
+  includeOptionContracts?: boolean;
 }): TickerSearchCandidate[] {
-  const providerHints = buildProviderHintMap(providerResults);
+  const candidateOptions = { includeOptionContracts };
+  const filteredProviderResults = includeOptionContracts
+    ? providerResults
+    : providerResults.filter((result) => !isOptionSearchResult(result));
+  const providerHints = buildProviderHintMap(filteredProviderResults);
   const localItems = rankTickerSearchItems(
-    createLocalTickerSearchCandidates(tickers.values(), providerHints),
+    createLocalTickerSearchCandidates(tickers.values(), providerHints, candidateOptions),
     query,
   );
-  const providerItems = createProviderTickerSearchCandidates(providerResults, tickers);
+  const providerItems = createProviderTickerSearchCandidates(filteredProviderResults, tickers, candidateOptions);
   const ranked = rankTickerSearchItems([...localItems, ...providerItems], query);
   return limitTickerSearchCandidates(assignTickerSearchCategories(ranked), totalLimit, localLimit);
 }
@@ -551,6 +570,31 @@ function shouldReplaceAssetCategory(currentCategory: string | undefined, nextCat
   return currentClass === "equity" && nextClass !== "equity";
 }
 
+function isOptionTickerRecord(ticker: TickerRecord): boolean {
+  return isOptionType(ticker.metadata.assetCategory)
+    || parseOptionSymbol(ticker.metadata.ticker) != null
+    || (ticker.metadata.broker_contracts ?? []).some(isOptionBrokerContract);
+}
+
+function isOptionSearchResult(result: InstrumentSearchResult): boolean {
+  return isOptionType(result.type)
+    || parseOptionSymbol(result.symbol) != null
+    || isOptionBrokerContract(result.brokerContract);
+}
+
+function isOptionBrokerContract(contract: InstrumentSearchResult["brokerContract"]): boolean {
+  if (!contract) return false;
+  return isOptionType(contract.secType)
+    || parseOptionSymbol(contract.localSymbol || "") != null
+    || contract.right === "C"
+    || contract.right === "P"
+    || contract.strike != null;
+}
+
+function isOptionType(rawType?: string): boolean {
+  return OPTION_TYPES.has(normalizeSearchText(rawType || ""));
+}
+
 function analyzeSearchQuery(query: string): SearchQueryIntent {
   const normalizedQuery = normalizeSearchText(query);
   const compactQuery = compactSearchText(query);

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.7.0";
+export const VERSION = "0.7.1";