gloomberb 0.9.8 → 0.9.10

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,151 @@
+import { expect, test } from "bun:test";
+import {
+  appReducer,
+  createInitialState,
+  type AppAction,
+  type AppState,
+} from "../core/state/app/state";
+import type { TickerRepository } from "../data/ticker-repository";
+import { createDefaultConfig } from "../types/config";
+import {
+  __syncContributorInternalsForTests,
+  coreConfigSyncContributor,
+} from "./core-contributors";
+import { CloudSyncController } from "./controller";
+import {
+  SYNC_SNAPSHOT_SCHEMA_VERSION,
+  type SyncContributor,
+  type SyncSnapshot,
+  type SyncSnapshotResponse,
+  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({
+    getState: () => ({} 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" });
+});
+
+test("keeps startup layout changes while serializing pull and push", async () => {
+  let state = createInitialState(createDefaultConfig("/tmp/gloomberb-sync-controller-test"));
+  const dispatch = (action: AppAction) => {
+    state = appReducer(state, action);
+  };
+  let resolvePull!: (response: SyncSnapshotResponse) => void;
+  const deferredPull = new Promise<SyncSnapshotResponse>((resolve) => {
+    resolvePull = resolve;
+  });
+  let pulls = 0;
+  const pushes: Array<{
+    snapshot: SyncSnapshot;
+    options?: { baseRevision?: number | null };
+  }> = [];
+  const transport: SyncTransport = {
+    id: "deferred-pull",
+    isAvailable: () => true,
+    pullSnapshot: () => {
+      pulls += 1;
+      return deferredPull;
+    },
+    pushSnapshot: async (snapshot, options) => {
+      pushes.push({ snapshot, options });
+      return { revision: 8, updatedAt: "2026-07-13T10:00:08.000Z" };
+    },
+  };
+  const contributor: SyncContributor = {
+    ...coreConfigSyncContributor,
+    apply: (payload, context) => {
+      const config = __syncContributorInternalsForTests.mergeConfigPayload(
+        context.state.config,
+        payload,
+        context.baselineState.config,
+      );
+      if (config) context.dispatch({ type: "SET_CONFIG", config });
+    },
+  };
+  const controller = new CloudSyncController();
+  controller.setRuntime({
+    getState: () => state,
+    dispatch,
+    tickerRepository: {} as TickerRepository,
+    getContributors: () => [{ pluginId: "test", contributor }],
+    getTransport: () => ({ pluginId: "test", transport }),
+  });
+
+  const startupSync = controller.requestSync({ reason: "startup" });
+  const startupPane = {
+    instanceId: "help:startup",
+    paneId: "help",
+    binding: { kind: "none" as const },
+  };
+  const localLayout = {
+    ...state.config.layout,
+    instances: [...state.config.layout.instances, startupPane],
+    floating: [
+      ...state.config.layout.floating,
+      { instanceId: startupPane.instanceId, x: 4, y: 3, width: 60, height: 20 },
+    ],
+  };
+  dispatch({
+    type: "SET_CONFIG",
+    config: {
+      ...state.config,
+      layout: localLayout,
+      layouts: state.config.layouts.map((saved, index) => (
+        index === state.config.activeLayoutIndex ? { ...saved, layout: localLayout } : saved
+      )),
+    },
+  });
+  const queuedPush = controller.requestSync({ reason: "state-change" });
+
+  const remoteConfig = createDefaultConfig("/remote/path-is-not-synced");
+  remoteConfig.theme = "green";
+  resolvePull({
+    snapshot: {
+      schemaVersion: SYNC_SNAPSHOT_SCHEMA_VERSION,
+      appId: "gloomberb",
+      clientId: "remote-client",
+      createdAt: "2026-07-13T10:00:07.000Z",
+      contributors: {
+        "core.config": {
+          schemaVersion: 1,
+          updatedAt: "2026-07-13T10:00:07.000Z",
+          payload: __syncContributorInternalsForTests.collectCoreConfigPayload(remoteConfig),
+        },
+      },
+    },
+    revision: 7,
+    updatedAt: "2026-07-13T10:00:07.000Z",
+  });
+  await Promise.all([startupSync, queuedPush]);
+
+  const pushedConfig = pushes[0]?.snapshot.contributors["core.config"]?.payload as {
+    layout: AppState["config"]["layout"];
+  };
+  expect(pulls).toBe(1);
+  expect(pushes).toHaveLength(1);
+  expect(pushes[0]?.options).toEqual({ baseRevision: 7 });
+  expect(state.config.theme).toBe("green");
+  expect(state.config.layout.instances).toContainEqual(startupPane);
+  expect(pushedConfig.layout.instances).toContainEqual(startupPane);
+});