gloomberb 0.9.8 → 0.9.9

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

@@ -1,5 +1,5 @@
 import type { MarketDataRequestContext } from "../../types/data-provider";
-import type { OptionContract, OptionsChain, Quote } from "../../types/financials";
+import type { MarketState, OptionContract, OptionsChain, Quote } from "../../types/financials";
 import { parseOptionSymbol } from "../../utils/options";
 import { getYahooSymbolsToTry } from "./symbols";
 
@@ -14,16 +14,40 @@ interface LoadYahooOptionsChainOptions {
 
 interface GetYahooOptionQuoteOptions {
   context?: MarketDataRequestContext;
-  getOptionsChain: (
+  getOptionsChainResult: (
     ticker: string,
     exchange?: string,
     expirationDate?: number,
     context?: MarketDataRequestContext,
-  ) => Promise<OptionsChain>;
+  ) => Promise<YahooOptionsChainResult>;
   providerId: string;
   ticker: string;
 }
 
+export interface YahooOptionsChainResult {
+  chain: OptionsChain;
+  underlyingMarketState?: MarketState;
+}
+
+const MARKET_STATES = new Set<MarketState>([
+  "PRE",
+  "REGULAR",
+  "POST",
+  "PREPRE",
+  "POSTPOST",
+  "CLOSED",
+]);
+
+function normalizeYahooMarketState(value: unknown): MarketState | undefined {
+  const normalized = typeof value === "string" ? value.toUpperCase() as MarketState : undefined;
+  return normalized && MARKET_STATES.has(normalized) ? normalized : undefined;
+}
+
+function deriveOptionMarketState(underlyingMarketState?: MarketState): MarketState | undefined {
+  if (!underlyingMarketState) return undefined;
+  return underlyingMarketState === "REGULAR" ? "REGULAR" : "CLOSED";
+}
+
 function mapYahooOptionContract(raw: Record<string, any>): OptionContract {
   return {
     contractSymbol: raw.contractSymbol ?? "",
@@ -43,12 +67,12 @@ function mapYahooOptionContract(raw: Record<string, any>): OptionContract {
   };
 }
 
-export async function loadYahooOptionsChain({
+export async function loadYahooOptionsChainResult({
   exchange,
   expirationDate,
   fetchJsonWithCrumb,
   ticker,
-}: LoadYahooOptionsChainOptions): Promise<OptionsChain> {
+}: LoadYahooOptionsChainOptions): Promise<YahooOptionsChainResult> {
   const symbolsToTry = getYahooSymbolsToTry(ticker, exchange);
   let lastError: any;
 
@@ -62,6 +86,7 @@ export async function loadYahooOptionsChain({
           result?: Array<{
             underlyingSymbol?: string;
             expirationDates?: number[];
+            quote?: { marketState?: unknown };
             options?: Array<{
               calls?: Array<Record<string, any>>;
               puts?: Array<Record<string, any>>;
@@ -75,10 +100,13 @@ export async function loadYahooOptionsChain({
 
       const opts = result.options?.[0];
       return {
-        underlyingSymbol: result.underlyingSymbol ?? symbol,
-        expirationDates: result.expirationDates ?? [],
-        calls: (opts?.calls ?? []).map((contract) => mapYahooOptionContract(contract)),
-        puts: (opts?.puts ?? []).map((contract) => mapYahooOptionContract(contract)),
+        chain: {
+          underlyingSymbol: result.underlyingSymbol ?? symbol,
+          expirationDates: result.expirationDates ?? [],
+          calls: (opts?.calls ?? []).map((contract) => mapYahooOptionContract(contract)),
+          puts: (opts?.puts ?? []).map((contract) => mapYahooOptionContract(contract)),
+        },
+        underlyingMarketState: normalizeYahooMarketState(result.quote?.marketState),
       };
     } catch (err) {
       lastError = err;
@@ -87,15 +115,26 @@ export async function loadYahooOptionsChain({
   throw lastError || new Error(`No options chain for ${ticker}`);
 }
 
+export async function loadYahooOptionsChain(
+  options: LoadYahooOptionsChainOptions,
+): Promise<OptionsChain> {
+  return (await loadYahooOptionsChainResult(options)).chain;
+}
+
 export async function getYahooOptionQuote({
   context,
-  getOptionsChain,
+  getOptionsChainResult,
   providerId,
   ticker,
 }: GetYahooOptionQuoteOptions): Promise<Quote> {
   const parsed = parseOptionSymbol(ticker);
   if (!parsed) throw new Error(`Unsupported option symbol ${ticker}`);
-  const chain = await getOptionsChain(parsed.underlying, "", parsed.expTs, context);
+  const { chain, underlyingMarketState } = await getOptionsChainResult(
+    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 &&
@@ -110,6 +149,12 @@ export async function getYahooOptionQuote({
       : contract.ask > 0
         ? contract.ask
         : undefined;
+  const marketState = deriveOptionMarketState(underlyingMarketState);
+  const lastUpdated = mark != null
+    ? Date.now()
+    : contract.lastTradeDate > 0
+      ? contract.lastTradeDate * 1000
+      : Date.now();
   return {
     symbol: ticker,
     providerId,
@@ -122,13 +167,13 @@ export async function getYahooOptionQuote({
     ask: contract.ask,
     mark,
     name: contract.contractSymbol,
-    lastUpdated: contract.lastTradeDate > 0
-      ? contract.lastTradeDate * 1000
-      : Date.now(),
+    lastUpdated,
     exchangeName: "OPTIONS",
     fullExchangeName: "OPTIONS",
     listingExchangeName: "OPTIONS",
     listingExchangeFullName: "OPTIONS",
+    marketState,
+    sessionConfidence: marketState ? "derived" : "unknown",
     dataSource: "delayed",
   };
 }

package/src/sources/yahoo-finance/quote-summary.ts

@@ -29,7 +29,10 @@ interface YahooQuoteSummaryOptions {
 }
 
 interface YahooCorporateActionsOptions extends YahooQuoteSummaryOptions {
-  fetchChart: (symbol: string, range: string, interval?: string) => Promise<ChartResult>;
+  fetchChart: (symbol: string, range: string, interval?: string) => Promise<{
+    meta: NonNullable<ChartResult["meta"]>;
+    events?: ChartResult["events"];
+  }>;
 }
 
 export async function loadYahooHolders({

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

@@ -135,28 +135,38 @@ describe("YahooFinanceClient exchange aliases", () => {
 
   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 expiration = 1_821_139_200;
+    let underlyingMarketState = "POST";
+    provider.http.fetchJsonWithCrumb = async () => ({
+      optionChain: {
+        result: [{
+          underlyingSymbol: "AMD",
+          expirationDates: [expiration],
+          quote: { marketState: underlyingMarketState },
+          options: [{
+            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,
+              lastTradeDate: 1_800_000_000,
+            }],
+            puts: [],
+          }],
+        }],
+      },
     });
 
+    const requestedAt = Date.now();
     const quote = await provider.getQuote("AMD   270917C00230000");
 
     expect(quote).toMatchObject({
@@ -166,8 +176,17 @@ describe("YahooFinanceClient exchange aliases", () => {
       bid: 250.25,
       ask: 254.5,
       providerId: "yahoo",
+      marketState: "CLOSED",
+      sessionConfidence: "derived",
+    });
+    expect(quote.lastUpdated).toBeGreaterThanOrEqual(requestedAt);
+
+    underlyingMarketState = "REGULAR";
+    const regularQuote = await provider.getQuote("AMD   270917C00230000");
+    expect(regularQuote).toMatchObject({
+      marketState: "REGULAR",
+      sessionConfidence: "derived",
     });
-    expect(quote.lastUpdated).toBe(1_800_000_000_000);
   });
 
   test("preserves analyst rating price targets from upgrade history", async () => {

package/src/sources/yahoo-finance.ts

@@ -31,6 +31,7 @@ import {
 import {
   getYahooOptionQuote,
   loadYahooOptionsChain,
+  loadYahooOptionsChainResult,
 } from "./yahoo-finance/options";
 import {
   loadYahooAnalystResearch,
@@ -155,8 +156,13 @@ export class YahooFinanceClient implements DataProvider {
     if (parseOptionSymbol(ticker)) {
       return getYahooOptionQuote({
         context,
-        getOptionsChain: (underlying, requestExchange, expirationDate, requestContext) => (
-          this.getOptionsChain(underlying, requestExchange, expirationDate, requestContext)
+        getOptionsChainResult: (underlying, requestExchange, expirationDate) => (
+          loadYahooOptionsChainResult({
+            exchange: requestExchange ?? "",
+            expirationDate,
+            fetchJsonWithCrumb: (url) => this.http.fetchJsonWithCrumb(url),
+            ticker: underlying,
+          })
         ),
         providerId: this.id,
         ticker,
@@ -189,13 +195,12 @@ export class YahooFinanceClient implements DataProvider {
     fromCurrency = normalized;
     if (fromCurrency === "USD") return 1;
 
-    try {
-      const { meta, history } = await this.fetchChart(`${fromCurrency}USD=X`, "1mo");
-      const rate = meta.regularMarketPrice || history[history.length - 1]?.close || 1;
-      return rate;
-    } catch {
-      return 1;
+    const { meta, history } = await this.fetchChart(`${fromCurrency}USD=X`, "1mo");
+    const rate = meta.regularMarketPrice ?? history[history.length - 1]?.close;
+    if (typeof rate !== "number" || !Number.isFinite(rate) || rate <= 0) {
+      throw new Error(`No exchange rate data for ${fromCurrency}/USD`);
     }
+    return rate;
   }
 
   /** Search for a ticker by name/symbol - uses direct fetch (no retry) for speed */

package/src/state/app/context/index.test.tsx

@@ -4,87 +4,6 @@ import { appReducer, createInitialState } from "./index";
 import { removePane } from "../../../plugins/pane-manager";
 
 describe("appReducer command bar state", () => {
-  test("opens the command bar with an explicit query", () => {
-    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-    const next = appReducer(state, { type: "SET_COMMAND_BAR", open: true, query: "Sync Broker Account" });
-
-    expect(next.commandBarOpen).toBe(true);
-    expect(next.commandBarQuery).toBe("Sync Broker Account");
-  });
-
-  test("clears the command bar query when closing", () => {
-    const state = appReducer(
-      createInitialState(createDefaultConfig("/tmp/gloomberb-test")),
-      { type: "SET_COMMAND_BAR", open: true, query: "Disconnect Broker Account" },
-    );
-    const next = appReducer(state, { type: "SET_COMMAND_BAR", open: false });
-
-    expect(next.commandBarOpen).toBe(false);
-    expect(next.commandBarQuery).toBe("");
-  });
-
-  test("stores and clears command bar launch requests", () => {
-    const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-    const opened = appReducer(initial, {
-      type: "SET_COMMAND_BAR",
-      open: true,
-      launch: { kind: "plugin-command", commandId: "set-alert" },
-    });
-    const relaunched = appReducer(opened, {
-      type: "SET_COMMAND_BAR",
-      open: true,
-      launch: { kind: "plugin-command", commandId: "set-alert" },
-    });
-    const closed = appReducer(relaunched, { type: "SET_COMMAND_BAR", open: false });
-
-    expect(opened.commandBarOpen).toBe(true);
-    expect(opened.commandBarLaunchRequest).toEqual({
-      kind: "plugin-command",
-      commandId: "set-alert",
-      sequence: 1,
-    });
-    expect(relaunched.commandBarLaunchRequest?.sequence).toBe(2);
-    expect(closed.commandBarLaunchRequest).toBeNull();
-  });
-
-  test("stores ticker search command bar launch requests", () => {
-    const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-    const opened = appReducer(initial, {
-      type: "SET_COMMAND_BAR",
-      open: true,
-      launch: { kind: "ticker-search", query: "" },
-    });
-
-    expect(opened.commandBarOpen).toBe(true);
-    expect(opened.commandBarLaunchRequest).toEqual({
-      kind: "ticker-search",
-      query: "",
-      sequence: 1,
-    });
-  });
-
-  test("toggle opens blank and clears on close", () => {
-    const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
-    const opened = appReducer(initial, { type: "TOGGLE_COMMAND_BAR" });
-    const closed = appReducer({ ...opened, commandBarQuery: "stale" }, { type: "TOGGLE_COMMAND_BAR" });
-
-    expect(opened.commandBarOpen).toBe(true);
-    expect(opened.commandBarQuery).toBe("");
-    expect(closed.commandBarOpen).toBe(false);
-    expect(closed.commandBarQuery).toBe("");
-  });
-
-  test("updates the live command bar query without closing the overlay", () => {
-    const state = appReducer(
-      createInitialState(createDefaultConfig("/tmp/gloomberb-test")),
-      { type: "SET_COMMAND_BAR", open: true, query: "PL " },
-    );
-    const next = appReducer(state, { type: "SET_COMMAND_BAR_QUERY", query: "PL notes" });
-
-    expect(next.commandBarOpen).toBe(true);
-    expect(next.commandBarQuery).toBe("PL notes");
-  });
-
   test("re-shows the gridlock tip and refreshes its sequence on every trigger", () => {
     const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
 

package/src/state/app/context/selector.test.tsx

@@ -82,8 +82,12 @@ function createDesktopBridge(
 }
 
 describe("pane selectors", () => {
-  afterEach(() => {
-    testSetup?.renderer.destroy();
+  afterEach(async () => {
+    if (testSetup) {
+      await act(async () => {
+        testSetup!.renderer.destroy();
+      });
+    }
     testSetup = undefined;
     capturedDispatch = null;
     applyTheme("amber");

package/src/sync/controller.test.ts

@@ -0,0 +1,31 @@
+import { expect, test } from "bun:test";
+import type { AppState } from "../core/state/app/state";
+import type { TickerRepository } from "../data/ticker-repository";
+import { CloudSyncController } from "./controller";
+import type { SyncTransport } from "./types";
+
+test("does not push local state when the initial pull fails", async () => {
+  let pushes = 0;
+  const transport: SyncTransport = {
+    id: "failing-pull",
+    isAvailable: () => true,
+    pullSnapshot: () => Promise.reject(new Error("pull failed")),
+    pushSnapshot: async () => {
+      pushes += 1;
+      return { revision: 1, updatedAt: new Date().toISOString() };
+    },
+  };
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    state: {} as AppState,
+    dispatch: () => {},
+    tickerRepository: {} as TickerRepository,
+    getContributors: () => [],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  await controller.requestSync({ force: true });
+
+  expect(pushes).toBe(0);
+  expect(controller.getStatus()).toMatchObject({ phase: "error", error: "pull failed" });
+});

package/src/sync/controller.ts

@@ -1,6 +1,7 @@
 import type { Dispatch } from "react";
 import type { AppAction, AppState } from "../core/state/app/state";
 import type { TickerRepository } from "../data/ticker-repository";
+import { stableStringify } from "../remote/revision";
 import {
   SYNC_SNAPSHOT_SCHEMA_VERSION,
   type RegisteredSyncContributor,
@@ -37,15 +38,6 @@ function nowIso(): string {
   return new Date().toISOString();
 }
 
-function stableStringify(value: unknown): string {
-  if (value == null || typeof value !== "object") return JSON.stringify(value);
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-  const entries = Object.entries(value as Record<string, unknown>)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child)}`);
-  return `{${entries.join(",")}}`;
-}
-
 function resolveClientId(): string {
   const storage = globalThis.localStorage;
   const existing = storage?.getItem(CLIENT_ID_STORAGE_KEY);
@@ -55,13 +47,14 @@ function resolveClientId(): string {
   return id;
 }
 
-class CloudSyncController {
+export class CloudSyncController {
   private runtime: SyncRuntime | null = null;
   private contributors = new Map<string, RegisteredSyncContributor>();
   private transports = new Map<string, RegisteredSyncTransport>();
   private listeners = new Set<() => void>();
   private pushTimer: ReturnType<typeof setTimeout> | null = null;
   private inFlight: Promise<void> | null = null;
+  private syncQueued = false;
   private clientId: string | null = null;
   private lastSignature: string | null = null;
   private lastPulledAtMs = 0;
@@ -116,6 +109,7 @@ class CloudSyncController {
     this.runtime = null;
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = null;
+    this.syncQueued = false;
   }
 
   subscribe(listener: () => void): () => void {
@@ -141,14 +135,21 @@ class CloudSyncController {
     }
     if (this.pushTimer) clearTimeout(this.pushTimer);
     this.pushTimer = setTimeout(() => {
+      this.pushTimer = null;
       void this.requestSync({ reason });
     }, PUSH_DEBOUNCE_MS);
   }
 
   async requestSync(options: { reason?: string; force?: boolean } = {}): Promise<void> {
-    if (this.inFlight) return this.inFlight;
-    const run = this.syncOnce(options).finally(() => {
+    if (this.inFlight) {
+      this.syncQueued = true;
+      return this.inFlight;
+    }
+    const run = this.syncOnce(options).finally(async () => {
       this.inFlight = null;
+      if (!this.syncQueued) return;
+      this.syncQueued = false;
+      await this.requestSync({ reason: "queued-state-change" });
     });
     this.inFlight = run;
     return run;
@@ -164,8 +165,9 @@ class CloudSyncController {
     }
     const currentMs = Date.now();
     if (!options.force && currentMs - this.lastPulledAtMs < PULL_MIN_INTERVAL_MS) return;
-    this.lastPulledAtMs = currentMs;
-    await this.runPull(runtime, transport.transport);
+    if (await this.runPull(runtime, transport.transport)) {
+      this.lastPulledAtMs = currentMs;
+    }
   }
 
   private async syncOnce(options: { reason?: string; force?: boolean }): Promise<void> {
@@ -178,7 +180,7 @@ class CloudSyncController {
     }
     const transport = transportRegistration.transport;
     if (!this.hasPulledForTransport.has(transport.id)) {
-      await this.runPull(runtime, transport);
+      if (!await this.runPull(runtime, transport)) return;
       this.hasPulledForTransport.add(transport.id);
     }
 
@@ -206,7 +208,7 @@ class CloudSyncController {
     }
   }
 
-  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<void> {
+  private async runPull(runtime: SyncRuntime, transport: SyncTransport): Promise<boolean> {
     this.setStatus({ phase: "syncing", transportId: transport.id, error: null });
     try {
       const response = await transport.pullSnapshot();
@@ -218,7 +220,7 @@ class CloudSyncController {
         lastSyncAt: response.updatedAt,
         error: null,
       });
-      if (!response.snapshot) return;
+      if (!response.snapshot) return true;
       for (const entry of runtime.getContributors()) {
         const payload = response.snapshot.contributors[entry.contributor.id]?.payload;
         if (payload === undefined || !entry.contributor.apply) continue;
@@ -229,12 +231,14 @@ class CloudSyncController {
           tickerRepository: runtime.tickerRepository,
         });
       }
+      return true;
     } catch (error) {
       this.setStatus({
         phase: "error",
         transportId: transport.id,
         error: error instanceof Error ? error.message : String(error),
       });
+      return false;
     }
   }
 

package/src/test-support/data-provider.ts

@@ -14,7 +14,6 @@ export function createTestDataProvider(overrides: Partial<DataProvider> = {}): D
     getQuote: async () => unused<Quote>("getQuote"),
     getExchangeRate: async () => 1,
     search: async () => [] satisfies InstrumentSearchResult[],
-    getNews: async () => [],
     getArticleSummary: async () => null,
     getPriceHistory: async () => [],
     ...overrides,

package/src/ui/host.tsx

@@ -101,6 +101,7 @@ interface ScrollBarRenderable {
 }
 
 export interface ScrollBoxRenderable {
+  width?: number;
   scrollTop: number;
   scrollLeft?: number;
   scrollHeight: number;
@@ -272,7 +273,7 @@ export interface HostCheckboxProps {
   disabled?: boolean;
   active?: boolean;
   description?: string;
-  width?: number;
+  width?: number | string;
   variant?: "default" | "desktop";
 }
 

package/src/ui/index.tsx

@@ -33,6 +33,7 @@ export {
 } from "./context-menu";
 export { contextMenuDivider } from "../types/context-menu";
 export type {
+  BitmapSurface,
   BoxRenderable,
   ChartSurfaceProps,
   HostCheckboxProps,

package/src/updater.test.ts

@@ -4,7 +4,6 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { gzipSync } from "zlib";
 import {
-  canSelfUpdate,
   checkForUpdate,
   checkForUpdateDetailed,
   detectUpdateAction,
@@ -153,26 +152,6 @@ describe("resolveSelfUpdateTargetPath", () => {
   });
 });
 
-describe("canSelfUpdate", () => {
-  test("returns false for manual update releases", () => {
-    expect(canSelfUpdate({
-      updateAction: { kind: "manual", command: "bun install -g gloomberb@latest" },
-    })).toBe(false);
-  });
-
-  test("returns true for self-update releases", () => {
-    expect(canSelfUpdate({
-      updateAction: { kind: "self" },
-    })).toBe(true);
-  });
-
-  test("returns true for desktop update releases", () => {
-    expect(canSelfUpdate({
-      updateAction: { kind: "desktop" },
-    })).toBe(true);
-  });
-});
-
 describe("update host", () => {
   test("delegates update checks to an installed host", async () => {
     setUpdateHost({