gloomberb 0.18.1 → 0.18.2

package/src/plugins/builtin/news/wire/feed-config.ts

@@ -9,11 +9,13 @@ const USER_FEEDS_KEY = "feeds";
 const DISABLED_DEFAULT_FEED_IDS_KEY = "disabledDefaultFeedIds";
 
 const DEFAULT_FEED_IDS = new Set(DEFAULT_FEEDS.map((feed) => feed.id));
+const UNREADABLE_SETTINGS = "News feed settings could not be read. Saved settings were kept.";
 
 export interface NewsFeedSettings {
   userFeeds: RssFeedConfig[];
   disabledDefaultFeedIds: string[];
   needsMigration: boolean;
+  error?: string;
 }
 
 export interface UserNewsFeedInput {
@@ -25,15 +27,15 @@ export interface UserNewsFeedInput {
   enabled?: boolean;
 }
 
-function parseJsonArray(value: unknown): unknown[] {
+function parseJsonArray(value: unknown): unknown[] | null {
   if (Array.isArray(value)) return value;
-  if (typeof value !== "string" || !value.trim()) return [];
+  if (typeof value !== "string") return [];
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed : [];
   } catch (error) {
     logFailure("news.feed-config", "Read stored news feed settings failed")(error);
-    return [];
+    return null;
   }
 }
 
@@ -134,14 +136,20 @@ function sameIdList(raw: unknown, normalized: string[]): boolean {
 }
 
 export function loadNewsFeedSettings(configState: PluginConfigState): NewsFeedSettings {
-  const rawUserFeeds = configState.get<unknown>(USER_FEEDS_KEY);
+  return parseNewsFeedSettings(configState.get(USER_FEEDS_KEY), configState.get(DISABLED_DEFAULT_FEED_IDS_KEY));
+}
+
+export function parseNewsFeedSettings(rawUserFeeds: unknown, rawDisabledIds: unknown): NewsFeedSettings {
   const userFeedValues = parseJsonArray(rawUserFeeds);
-  const userFeeds = userFeedValues
+  const userFeeds = (userFeedValues ?? [])
     .map(normalizeUserFeed)
     .filter((feed): feed is RssFeedConfig => !!feed);
 
-  const rawDisabledIds = configState.get<unknown>(DISABLED_DEFAULT_FEED_IDS_KEY);
-  const disabledDefaultFeedIds = normalizeDisabledDefaultFeedIds(parseJsonArray(rawDisabledIds));
+  const disabledIdValues = parseJsonArray(rawDisabledIds);
+  const disabledDefaultFeedIds = normalizeDisabledDefaultFeedIds(disabledIdValues ?? []);
+  if (userFeedValues === null || disabledIdValues === null) {
+    return { userFeeds, disabledDefaultFeedIds, needsMigration: false, error: UNREADABLE_SETTINGS };
+  }
 
   const needsMigration = (rawUserFeeds !== null && !sameUserFeeds(rawUserFeeds, userFeeds))
     || (rawDisabledIds !== null && !sameIdList(rawDisabledIds, disabledDefaultFeedIds));
@@ -149,15 +157,24 @@ export function loadNewsFeedSettings(configState: PluginConfigState): NewsFeedSe
   return { userFeeds, disabledDefaultFeedIds, needsMigration };
 }
 
+function requireReadableSettings(configState: PluginConfigState): NewsFeedSettings {
+  const settings = loadNewsFeedSettings(configState);
+  if (settings.error) throw new Error(settings.error);
+  return settings;
+}
+
 export async function saveNewsFeedSettings(
   configState: PluginConfigState,
   settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">,
 ): Promise<void> {
+  requireReadableSettings(configState);
   await configState.set(USER_FEEDS_KEY, settings.userFeeds);
+  requireReadableSettings(configState);
   await configState.set(DISABLED_DEFAULT_FEED_IDS_KEY, settings.disabledDefaultFeedIds);
 }
 
-export function getEnabledNewsFeeds(settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds">): RssFeedConfig[] {
+export function getEnabledNewsFeeds(settings: Pick<NewsFeedSettings, "userFeeds" | "disabledDefaultFeedIds" | "error">): RssFeedConfig[] {
+  if (settings.error) return [];
   const disabled = new Set(settings.disabledDefaultFeedIds);
   return [
     ...DEFAULT_FEEDS.filter((feed) => feed.enabled && !disabled.has(feed.id)),
@@ -169,7 +186,7 @@ export async function addUserNewsFeed(
   configState: PluginConfigState,
   input: UserNewsFeedInput,
 ): Promise<RssFeedConfig> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const feed = createUserFeed(input);
   const nextUserFeeds = [
     ...settings.userFeeds.filter((entry) => entry.id !== feed.id),
@@ -187,7 +204,7 @@ export async function updateUserNewsFeed(
   feedId: string,
   patch: Partial<UserNewsFeedInput>,
 ): Promise<RssFeedConfig | null> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const existing = settings.userFeeds.find((feed) => feed.id === feedId);
   if (!existing) return null;
   const nextFeed = createUserFeed({
@@ -206,7 +223,7 @@ export async function removeUserNewsFeed(
   configState: PluginConfigState,
   feedId: string,
 ): Promise<boolean> {
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const nextUserFeeds = settings.userFeeds.filter((feed) => feed.id !== feedId);
   if (nextUserFeeds.length === settings.userFeeds.length) return false;
   await saveNewsFeedSettings(configState, {
@@ -222,7 +239,7 @@ export async function setDefaultNewsFeedEnabled(
   enabled: boolean,
 ): Promise<boolean> {
   if (!DEFAULT_FEED_IDS.has(feedId)) return false;
-  const settings = loadNewsFeedSettings(configState);
+  const settings = requireReadableSettings(configState);
   const disabled = new Set(settings.disabledDefaultFeedIds);
   if (enabled) disabled.delete(feedId);
   else disabled.add(feedId);

package/src/plugins/builtin/news/wire/index.tsx

@@ -26,6 +26,7 @@ import { createRssNewsCapability } from "./rss/source";
 import { rssCliCommand } from "./rss/cli";
 import { newsFeedHeadless } from "../headless";
 import type { PaneDef } from "../../../../types/plugin";
+import { logFailure } from "../../../../utils/log-failure";
 
 const TopPane = createNewsPresetPane({
   paneKey: "top:curated",
@@ -195,11 +196,15 @@ export const newsWireModule: PluginModule = {
   setup(ctx) {
     const initialSettings = loadNewsFeedSettings(ctx.configState);
     if (initialSettings.needsMigration) {
-      void saveNewsFeedSettings(ctx.configState, initialSettings);
+      void saveNewsFeedSettings(ctx.configState, initialSettings)
+        .catch(logFailure("news.feed-config", "Migrate news feed settings failed"));
     }
 
     const source = createRssNewsCapability(
-      () => getEnabledNewsFeeds(loadNewsFeedSettings(ctx.configState)),
+      () => {
+        const settings = loadNewsFeedSettings(ctx.configState);
+        return { feeds: getEnabledNewsFeeds(settings), error: settings.error };
+      },
       { persistence: ctx.persistence },
     );
     ctx.registerCapability(source);

package/src/plugins/builtin/news/wire/news/preset-pane.tsx

@@ -1,9 +1,9 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import { Box } from "../../../../../ui";
 import type { NewsArticle, NewsQuery } from "../../../../../news/types";
 import { useLoadNewsStory, useNewsArticles, useNewsTableLoadMore } from "../../../../../news/hooks";
 import type { PaneProps } from "../../../../../types/plugin";
-import { useDebouncedPluginPaneState, usePluginPaneState } from "../../../../runtime";
+import { useDebouncedPluginPaneState, usePluginConfigState, usePluginPaneState } from "../../../../runtime";
 import { PaneStatusBody, QueryBar, type QueryBarSearch } from "../../../../../components";
 import { NewsDetailView, useNewsArticleDetail } from "./detail-view";
 import {
@@ -18,6 +18,7 @@ import { newsListEmptyCopy } from "../filter-articles";
 import { NEWS_LIST_SEARCH_PLACEHOLDER, useNewsListSearch, useNewsListSearchHint } from "./list-search";
 import { newsMutesApplyToFeed, useNewsMuteFilter } from "../mutes";
 import { usePopOutNewsArticle } from "./pop-out";
+import { parseNewsFeedSettings } from "../feed-config";
 
 interface NewsArticleStackOptions {
   /** Prefix of every key the pane persists, and of its footer registration. */
@@ -146,6 +147,13 @@ export function NewsPresetPane({
   emptyStateTitle,
   emptyStateHint,
 }: PaneProps & NewsPresetPaneConfig) {
+  const [storedFeeds] = usePluginConfigState<unknown>("feeds", null);
+  const [storedDisabledIds] = usePluginConfigState<unknown>("disabledDefaultFeedIds", null);
+  // The first query can finish before RSS registers, and desktop queries may
+  // use Cloud alone. A settings failure must remain visible in either case.
+  const settingsError = useMemo(() => query.feed === "latest"
+    ? parseNewsFeedSettings(storedFeeds, storedDisabledIds).error
+    : undefined, [query.feed, storedFeeds, storedDisabledIds]);
   const newsState = useNewsArticles(query);
   const persisted = usePersistedNewsArticles(`${paneKey}:articles`, newsState.articles);
   const articles = useNewsMuteFilter(persisted, newsMutesApplyToFeed(query.feed));
@@ -154,7 +162,7 @@ export function NewsPresetPane({
   // body rather than a definitive empty wire.
   const loading = newsState.phase === "loading"
     || (newsState.phase === "refreshing" && persisted.length === 0);
-  const error = newsState.error;
+  const error = settingsError ?? newsState.error;
   const { search, searchQuery, ...stack } = useNewsArticleStack({
     paneKey,
     articles,

package/src/plugins/builtin/news/wire/rss/cli.ts

@@ -26,8 +26,9 @@ export const rssCliCommand: CliCommandDef = {
       authority: 50,
       enabled: true,
     }]);
-    const articles = await capability.provider.fetchNews({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
-    ctx.printResult({ data: articles.map((article) => ({
+    const page = await capability.provider.fetchNewsPage!({ feed: "latest", limit: ctx.cliOptions.limit ?? 20 });
+    if (page.error) ctx.fail(page.error);
+    ctx.printResult({ data: page.articles.map((article) => ({
       title: article.title,
       source: article.source,
       publishedAt: article.publishedAt.toISOString(),

package/src/plugins/builtin/news/wire/rss/source.ts

@@ -129,11 +129,14 @@ function writeFeedCache(
 }
 
 export function createRssNewsCapability(
-  feedsOrGetter: RssFeedConfig[] | (() => RssFeedConfig[]),
+  feedsOrGetter: RssFeedConfig[] | (() => RssFeedConfig[] | { feeds: RssFeedConfig[]; error?: string }),
   options: RssNewsCapabilityOptions = {},
 ): NewsCapability {
   const fetchText = options.fetchText ?? ((url: string) => rssClient.fetch(url));
-  const getFeeds = () => Array.isArray(feedsOrGetter) ? feedsOrGetter : feedsOrGetter();
+  const getFeeds = () => {
+    const selection = Array.isArray(feedsOrGetter) ? feedsOrGetter : feedsOrGetter();
+    return Array.isArray(selection) ? { feeds: selection } : selection;
+  };
 
   async function fetchFeed(feed: RssFeedConfig): Promise<{ articles: MarketNewsItem[]; failed: boolean }> {
     const freshCache = readFeedCache(options.persistence, feed);
@@ -153,7 +156,9 @@ export function createRssNewsCapability(
 
   async function fetchPage(query: NewsQuery) {
     if (!supportsQuery(query)) return { articles: [] };
-    const feeds = getFeeds().filter((feed) => feed.enabled);
+    const selection = getFeeds();
+    if (selection.error) return { articles: [], error: selection.error };
+    const feeds = selection.feeds.filter((feed) => feed.enabled);
     const results = await Promise.all(feeds.map(fetchFeed));
     const failed = results.filter((result) => result.failed).length;
     return {
@@ -170,11 +175,15 @@ export function createRssNewsCapability(
       supports: supportsQuery,
       getCachedNews(query: NewsQuery): MarketNewsItem[] {
         if (!supportsQuery(query)) return [];
-        const enabledFeeds = getFeeds().filter((feed) => feed.enabled);
+        const selection = getFeeds();
+        if (selection.error) return [];
+        const enabledFeeds = selection.feeds.filter((feed) => feed.enabled);
         return enabledFeeds.flatMap((feed) => readFeedCache(options.persistence, feed, { allowExpired: true }) ?? []);
       },
       fetchNewsPage: fetchPage,
       async fetchNews(query: NewsQuery): Promise<MarketNewsItem[]> {
+        const error = supportsQuery(query) ? getFeeds().error : undefined;
+        if (error) throw new Error(error);
         return (await fetchPage(query)).articles;
       },
     },

package/src/plugins/builtin/options/footer.ts

@@ -1,5 +1,6 @@
 import { useMemo } from "react";
 import type { PaneFooterSegment, PaneHint } from "../../../components";
+import { delayedFooterSegment } from "../../../components/layout/pane/footer/model";
 import { t, tf } from "../../../i18n";
 import type { OptionsChain } from "../../../types/financials";
 import { formatRelativeTime } from "../../../utils/datetime-format";
@@ -9,18 +10,18 @@ import { CLOUD_QUOTE_DELAY_MINUTES } from "../../../api-client/plan-access";
 import type { OptionQuoteCoverage, OptionQuoteCoverageStatus } from "./live-quotes";
 import { formatOptionPrice, optionSpread, type OptionMarketReference } from "./market-reference";
 
-interface OptionsCoverageState {
-  text: string;
-  tone: "muted" | "positive" | "warning";
-}
-
-/** Stream coverage the pane reports once the account is entitled to real-time options. */
-function resolveOptionsCoverageState(status: OptionQuoteCoverageStatus): OptionsCoverageState | null {
-  if (status === "live") return { text: t("real-time options"), tone: "positive" };
-  if (status === "mixed") return { text: t("mixed real-time and delayed options"), tone: "warning" };
+/**
+ * Stream coverage the pane reports once the account is entitled to real-time
+ * options. Delayed quotes, all or some, are the footer's clock, its detail on
+ * hover.
+ */
+export function optionsCoverageSegment(status: OptionQuoteCoverageStatus, delayLabel?: string): PaneFooterSegment | null {
+  const id = "options-access";
+  if (status === "live") return { id, parts: [{ text: t("real-time options"), tone: "positive" }] };
+  if (status === "mixed") return delayedFooterSegment({ id, detail: t("mixed real-time and delayed options") });
   // The stream connects in the background; nothing to report until it answers.
   if (status === "connecting") return null;
-  return { text: t("options delayed fallback"), tone: "warning" };
+  return delayedFooterSegment({ id, detail: t("Delayed options quotes, real-time stream unavailable"), delay: delayLabel });
 }
 
 /**
@@ -82,6 +83,7 @@ export function resolveOptionsDelayLabel(chain: OptionsChain | null | undefined)
 }
 
 export function useOptionsAccessFooter({
+  broker = false,
   chain,
   error,
   focused,
@@ -91,6 +93,8 @@ export function useOptionsAccessFooter({
   reference,
   spreadColumnVisible,
 }: {
+  /** The chain is a broker profile's, quoted by that broker: it has no Gloom Cloud delay to report or upgrade from. */
+  broker?: boolean;
   chain: OptionsChain | null | undefined;
   error?: string | null;
   focused: boolean;
@@ -102,24 +106,25 @@ export function useOptionsAccessFooter({
   /** Set while the chain prints a SPRD column, so the status bar stops repeating it. */
   spreadColumnVisible?: boolean;
 }): void {
+  const delayLabel = resolveOptionsDelayLabel(chain);
   const { access, hint: upgradeHint, segment } = useCloudAccessFooter({
-    delayLabel: resolveOptionsDelayLabel(chain),
+    delayLabel,
+    degraded: !broker,
     focused,
     segmentId: "options-access",
     placement: "omon-footer",
     shortcutScope: "options:upgrade",
   });
-  // Trial accounts stream real-time too, but the countdown is the status worth the row.
-  const coverage = access.hasProAccess && !access.isTrialActive
-    ? resolveOptionsCoverageState(quoteCoverage.status)
-    : null;
-
+  // Trial accounts stream real-time too, but the countdown is the status worth the row. A broker's
+  // chain streams from the broker whatever the plan, so its coverage is the status, and its delay
+  // is the chain's own, not Gloom Cloud's.
+  const proCoverage = broker || (access.hasProAccess && !access.isTrialActive);
+  const coverageDelay = broker && !(chain?.delayMinutes && chain.delayMinutes > 0) ? undefined : delayLabel;
   const accessInfo = useMemo<PaneFooterSegment[]>(() => {
-    if (coverage) {
-      return [{ id: "options-access", parts: [{ text: coverage.text, tone: coverage.tone }] }];
-    }
+    const coverage = proCoverage ? optionsCoverageSegment(quoteCoverage.status, coverageDelay) : null;
+    if (coverage) return [coverage];
     return segment ? [segment] : [];
-  }, [coverage?.text, coverage?.tone, segment]);
+  }, [coverageDelay, proCoverage, quoteCoverage.status, segment]);
 
   // Rebuilt every render so the quote and trade ages keep counting with the
   // stream; the registration compares by value, so only a changed label

package/src/plugins/builtin/options/live-quotes.ts

@@ -1,6 +1,6 @@
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { OptionContract, OptionsChain, Quote } from "../../../types/financials";
-import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
+import { buildQuoteKey, instrumentFromQuoteTarget, resolveEntryData } from "../../../market-data/selectors";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { OptionTableRow } from "./types";
 import { isFiniteNumber } from "../../../utils/guards";
@@ -75,9 +75,20 @@ function normalizeVisibleRange(
   return { start, end };
 }
 
+/**
+ * The broker profile a chain came from. Its contracts' quotes are asked of the
+ * same profile, so a broker that streams options (and no cloud stream) keeps
+ * the chain it served current, rather than leaving it to a slower source.
+ */
+export interface OptionQuoteBroker {
+  brokerId?: string;
+  brokerInstanceId?: string;
+}
+
 export function buildOptionQuoteTargets(
   rows: readonly OptionTableRow[],
   window: OptionQuoteTargetWindow,
+  broker?: OptionQuoteBroker,
 ): QuoteSubscriptionTarget[] {
   if (rows.length === 0) return [];
   const visibleRange = normalizeVisibleRange(rows.length, window);
@@ -101,6 +112,7 @@ export function buildOptionQuoteTargets(
       targets.set(symbol, {
         symbol,
         exchange: OPTIONS_QUOTE_EXCHANGE,
+        ...(broker ? { context: { brokerId: broker.brokerId, brokerInstanceId: broker.brokerInstanceId } } : {}),
         surface: "options",
         visible,
         selected,
@@ -119,10 +131,12 @@ export function buildOptionQuoteTargets(
   return [...targets.values()];
 }
 
-export function buildOptionQuoteKey(contractSymbol: string): string {
+export function buildOptionQuoteKey(contractSymbol: string, broker?: OptionQuoteBroker): string {
   return buildQuoteKey({
     symbol: contractSymbol,
     exchange: OPTIONS_QUOTE_EXCHANGE,
+    brokerId: broker?.brokerId,
+    brokerInstanceId: broker?.brokerInstanceId,
   });
 }
 
@@ -179,17 +193,20 @@ export interface LiveOptionsChain {
 }
 
 const EMPTY_STRIKES: ReadonlySet<number> = new Set();
-const contractKeyIndexes = new WeakMap<readonly OptionContract[], Map<string, number[]>>();
+const contractKeyIndexes = new WeakMap<readonly OptionContract[], Map<string, Map<string, number[]>>>();
 
-function contractKeyIndex(contracts: readonly OptionContract[]): Map<string, number[]> {
-  let index = contractKeyIndexes.get(contracts);
+function contractKeyIndex(contracts: readonly OptionContract[], broker?: OptionQuoteBroker): Map<string, number[]> {
+  const byBroker = contractKeyIndexes.get(contracts) ?? new Map<string, Map<string, number[]>>();
+  contractKeyIndexes.set(contracts, byBroker);
+  const brokerKey = `${broker?.brokerId ?? ""}|${broker?.brokerInstanceId ?? ""}`;
+  let index = byBroker.get(brokerKey);
   if (!index) {
     index = new Map();
     contracts.forEach((contract, position) => {
-      const key = buildOptionQuoteKey(contract.contractSymbol);
+      const key = buildOptionQuoteKey(contract.contractSymbol, broker);
       index!.set(key, [...(index!.get(key) ?? []), position]);
     });
-    contractKeyIndexes.set(contracts, index);
+    byBroker.set(brokerKey, index);
   }
   return index;
 }
@@ -204,12 +221,13 @@ export function overlayOptionChainQuotes(
   chain: OptionsChain,
   quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
   freshness: OptionsQuoteFreshness,
+  broker?: OptionQuoteBroker,
 ): LiveOptionsChain {
   if (quoteEntries.size === 0) return { chain, streamedStrikes: EMPTY_STRIKES, quotedAt: null };
   const streamedStrikes = new Set<number>();
   let quotedAt: number | null = null;
   const overlay = (contracts: OptionContract[]): OptionContract[] => {
-    const index = contractKeyIndex(contracts);
+    const index = contractKeyIndex(contracts, broker);
     let next: OptionContract[] | null = null;
     for (const [key, entry] of quoteEntries) {
       const positions = index.get(key);
@@ -242,19 +260,16 @@ export function resolveOptionQuoteCoverage(
   quoteEntries: ReadonlyMap<string, QueryEntry<Quote>>,
   freshness: OptionsQuoteFreshness,
 ): OptionQuoteCoverage {
-  const visibleSymbols = new Set(
+  // Each target's own key: a chain's broker profile is part of it.
+  const visibleKeys = new Set(
     targets
-      .filter((target) => target.visible === true)
-      .map((target) => target.symbol.trim().toUpperCase())
-      .filter(Boolean),
+      .filter((target) => target.visible === true && target.symbol.trim())
+      .map((target) => buildQuoteKey(instrumentFromQuoteTarget(target))),
   );
   let liveCount = 0;
   let fallbackCount = 0;
-  for (const symbol of visibleSymbols) {
-    const quote = freshOptionQuote(
-      quoteEntries.get(buildOptionQuoteKey(symbol)),
-      freshness,
-    );
+  for (const key of visibleKeys) {
+    const quote = freshOptionQuote(quoteEntries.get(key), freshness);
     if (
       quote?.dataSource === "live"
       && quote.delivery === "stream"
@@ -266,7 +281,7 @@ export function resolveOptionQuoteCoverage(
     }
   }
 
-  const totalCount = visibleSymbols.size;
+  const totalCount = visibleKeys.size;
   const status: OptionQuoteCoverageStatus = totalCount > 0 && liveCount === totalCount
     ? "live"
     : liveCount > 0