gloomberb 0.16.3 → 0.16.5

package/src/brokers/signed-in/sign-in-dialog.tsx

@@ -13,14 +13,16 @@ import { t, tf } from "../../i18n";
 import { useAppLanguage } from "../../i18n/react";
 import { useViewport } from "../../react/input";
 import { colors } from "../../theme/colors";
-import { Box, Text, TextAttributes } from "../../ui";
+import { Box, Text, TextAttributes, useUiCapabilities } from "../../ui";
+import { DialogHints } from "../../components/ui/dialog-actions";
 import { useDialog, useDialogKeyboard, type DialogApi, type PromptContext } from "../../ui/dialog";
 import { isPlainKey } from "../../utils/keyboard";
-import { DeviceSignInDialog } from "../../plugins/builtin/cloud/device-signin-dialog";
+import { DeviceSignInDialog } from "../../account/device-signin-dialog";
 import type { SignedInBroker } from "./client";
 import {
   BrokerSignInController,
   runBrokerSignIn,
+  type BrokerSignInOptions,
   type BrokerSignInOutcome,
   type BrokerSignInSnapshot,
 } from "./sign-in";
@@ -59,9 +61,10 @@ export function useBrokerSignInAttempt(
   broker: SignedInBroker,
   write: boolean,
   onOutcome: (outcome: "connected" | "signed-out") => void,
+  options: BrokerSignInOptions = {},
 ): { snapshot: BrokerSignInSnapshot; restart(): void; finish(): void } {
   const controllerRef = useRef<BrokerSignInController | null>(null);
-  if (!controllerRef.current) controllerRef.current = new BrokerSignInController(broker, write);
+  if (!controllerRef.current) controllerRef.current = new BrokerSignInController(broker, write, {}, options);
   const controller = controllerRef.current;
   const [snapshot, setSnapshot] = useState(controller.getSnapshot());
   const onOutcomeRef = useRef(onOutcome);
@@ -110,12 +113,14 @@ function BrokerSignInDialog({
   dismiss,
   broker,
   write,
-}: PromptContext<BrokerSignInOutcome> & { broker: SignedInBroker; write: boolean }) {
+  renew,
+}: PromptContext<BrokerSignInOutcome> & { broker: SignedInBroker; write: boolean; renew: boolean }) {
   useAppLanguage();
+  const { nativePaneChrome } = useUiCapabilities();
   const { height: termHeight } = useViewport();
   // Close after a beat so "Connected" is visible; enter skips the wait. Signed
   // out closes at once, for the host to sign in to Gloom.
-  const { snapshot, restart, finish } = useBrokerSignInAttempt(broker, write, resolve);
+  const { snapshot, restart, finish } = useBrokerSignInAttempt(broker, write, resolve, { renew });
 
   useDialogKeyboard((event) => {
     event.stopPropagation();
@@ -159,9 +164,13 @@ function BrokerSignInDialog({
         </>
       )}
       <Box height={1} />
-      <Box height={1}>
-        <Text fg={colors.textMuted}>{t("r for a new code · esc to cancel")}</Text>
-      </Box>
+      {nativePaneChrome ? (
+        <DialogHints keys={[{ key: "r", label: "new code" }, { key: "Esc", label: "cancel" }]} />
+      ) : (
+        <Box height={1}>
+          <Text fg={colors.textMuted}>{t("r for a new code · esc to cancel")}</Text>
+        </Box>
+      )}
     </Box>
   );
 }
@@ -170,6 +179,8 @@ export interface BrokerSignInRequest {
   broker: SignedInBroker;
   /** Ask for trading as well as reading. Defaults to whether the broker takes orders. */
   write?: boolean;
+  /** Sign in again although the broker is connected. */
+  renew?: boolean;
   resolve: (connected: boolean) => void;
 }
 
@@ -178,13 +189,17 @@ const requestListeners = new Set<(request: BrokerSignInRequest) => void>();
 /**
  * Connects a signed-in broker, signing in to Gloom first when needed.
  * Resolves true once the broker is connected, false when the user cancels or
- * no dialog host is mounted.
+ * no dialog host is mounted. A broker that is already connected is done at
+ * once unless `renew` asks for a new sign-in.
  */
-export function requestBrokerSignIn(broker: SignedInBroker, options: { write?: boolean } = {}): Promise<boolean> {
+export function requestBrokerSignIn(
+  broker: SignedInBroker,
+  options: { write?: boolean; renew?: boolean } = {},
+): Promise<boolean> {
   if (requestListeners.size === 0) return Promise.resolve(false);
   return new Promise((resolve) => {
     const write = options.write ?? Boolean(broker.capabilities.orders);
-    for (const listener of requestListeners) listener({ broker, write, resolve });
+    for (const listener of requestListeners) listener({ broker, write, renew: options.renew, resolve });
   });
 }
 
@@ -203,13 +218,18 @@ export function BrokerSignInDialogHost() {
       void runBrokerSignIn(request.broker, request.write, {
         isSignedIn: () => apiClient.isSignedIn(),
         signInToGloom: () => promptGloomSignIn(dialog),
-        connectBroker: async (broker, write) => await dialog.prompt<BrokerSignInOutcome>({
+        connectBroker: async (broker, write, renew) => await dialog.prompt<BrokerSignInOutcome>({
           size: "full",
           content: (context: unknown) => (
-            <BrokerSignInDialog {...(context as PromptContext<BrokerSignInOutcome>)} broker={broker} write={write} />
+            <BrokerSignInDialog
+              {...(context as PromptContext<BrokerSignInOutcome>)}
+              broker={broker}
+              write={write}
+              renew={renew}
+            />
           ),
         }) ?? "cancelled",
-      })
+      }, { renew: request.renew })
         .then(request.resolve, () => request.resolve(false))
         .finally(() => {
           openRef.current = false;

package/src/brokers/signed-in/sign-in.ts

@@ -24,9 +24,21 @@ export interface BrokerSignInSnapshot {
   error: string | null;
 }
 
+/** What a read of the account's connection tells the flow. */
+export type BrokerConnectionRead = Pick<SignedInBrokerConnection, "status"> & { connectedAt?: string | null };
+
+export interface BrokerSignInOptions {
+  /**
+   * Sign in again although the broker is connected, to start a new sign-in
+   * before the broker ends the old one. Without it a connected broker is done
+   * at once, as when a device adds a connection the account already holds.
+   */
+  renew?: boolean;
+}
+
 export interface BrokerSignInIo {
   start(brokerId: string, write: boolean): Promise<{ connectUrl: string; code: string; expiresAt: string }>;
-  fetchConnection(brokerId: string): Promise<Pick<SignedInBrokerConnection, "status">>;
+  fetchConnection(brokerId: string): Promise<BrokerConnectionRead>;
   now(): number;
   delay(ms: number): Promise<void>;
 }
@@ -58,10 +70,37 @@ function codeDeadline(expiresAt: string, now: number): number {
   return Number.isFinite(parsed) && parsed > now ? parsed : now + DEFAULT_CODE_TTL_MS;
 }
 
+function stamp(value: string | null | undefined): number | null {
+  const parsed = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/**
+ * Whether `now` shows a sign-in made after `before` was read. Renewing a
+ * connection takes more than connected: a broker that was connected when the
+ * flow began stays connected while the user signs in again, until Gloom stamps
+ * the new sign-in. Both reads are Gloom's, so a device clock that runs fast or
+ * slow cannot matter.
+ */
+function signedInSince(before: BrokerConnectionRead, now: BrokerConnectionRead): boolean {
+  if (now.status !== "connected") return false;
+  if (before.status !== "connected") return true;
+  const at = stamp(now.connectedAt);
+  const was = stamp(before.connectedAt);
+  return at !== null && (was === null || at > was);
+}
+
 export class BrokerSignInController {
   private readonly io: BrokerSignInIo;
   private readonly listeners = new Set<(snapshot: BrokerSignInSnapshot) => void>();
   private generation = 0;
+  /**
+   * Renewing only: the account's connection as first seen. It outlives a
+   * restarted code, so a sign-in finished while "r" asked for a new one still
+   * counts.
+   */
+  private before: BrokerConnectionRead | null = null;
+  private readonly renew: boolean;
   private snapshot: BrokerSignInSnapshot = { phase: "starting", connectUrl: null, code: null, error: null };
 
   constructor(
@@ -69,8 +108,10 @@ export class BrokerSignInController {
     /** Ask for trading as well as reading when the broker offers it. */
     private readonly write: boolean,
     io: Partial<BrokerSignInIo> = {},
+    options: BrokerSignInOptions = {},
   ) {
     this.io = { ...defaultIo, ...io };
+    this.renew = options.renew === true;
   }
 
   getSnapshot(): BrokerSignInSnapshot {
@@ -102,6 +143,14 @@ export class BrokerSignInController {
   private async run(generation: number): Promise<void> {
     const stale = () => this.generation !== generation;
     let retryMs = POLL_INTERVAL_MS;
+    // Renewing: read before a code exists, so nothing the user does can come
+    // first. A failed read leaves the first poll to stand in for it: no
+    // sign-in finishes within a poll interval.
+    if (this.renew && !this.before) {
+      const read = await this.io.fetchConnection(this.broker.id).catch(() => null);
+      if (stale()) return;
+      this.before ??= read;
+    }
     // Each iteration is one code: start, poll until connected, and loop again
     // when the code expired so the link refreshes instead of dead-ending.
     while (!stale()) {
@@ -132,8 +181,14 @@ export class BrokerSignInController {
         await this.io.delay(POLL_INTERVAL_MS);
         if (stale()) return;
         try {
+          const connection = await this.io.fetchConnection(this.broker.id);
           // Connected is enough: a user who declined trading still gets a read-only connection.
-          if ((await this.io.fetchConnection(this.broker.id)).status === "connected") {
+          let done = connection.status === "connected";
+          if (this.renew) {
+            this.before ??= connection;
+            done = signedInSince(this.before, connection);
+          }
+          if (done) {
             if (!stale()) this.update({ phase: "connected", error: null });
             this.generation += 1;
             return;
@@ -154,7 +209,7 @@ export interface BrokerSignInSteps {
   isSignedIn(): boolean;
   /** The Gloom device sign-in; true once signed in. */
   signInToGloom(): Promise<boolean>;
-  connectBroker(broker: SignedInBroker, write: boolean): Promise<BrokerSignInOutcome>;
+  connectBroker(broker: SignedInBroker, write: boolean, renew: boolean): Promise<BrokerSignInOutcome>;
 }
 
 /**
@@ -166,13 +221,15 @@ export async function runBrokerSignIn(
   broker: SignedInBroker,
   write: boolean | undefined,
   steps: BrokerSignInSteps,
+  options: BrokerSignInOptions = {},
 ): Promise<boolean> {
   if (!steps.isSignedIn() && !await steps.signInToGloom()) return false;
   // Trading is asked for only where the broker takes orders from Gloom.
   const scope = write ?? Boolean(broker.capabilities.orders);
-  let outcome = await steps.connectBroker(broker, scope);
+  const renew = options.renew === true;
+  let outcome = await steps.connectBroker(broker, scope, renew);
   if (outcome === "signed-out" && await steps.signInToGloom()) {
-    outcome = await steps.connectBroker(broker, scope);
+    outcome = await steps.connectBroker(broker, scope, renew);
   }
   return outcome === "connected";
 }

package/src/capabilities/chart-series.ts

@@ -253,17 +253,27 @@ export const chartSeriesCatalogOutputSchema: CapabilitySchema<ChartSeriesCatalog
 export const chartSeriesResolveRequestSchema: CapabilitySchema<ChartSeriesResolveRequest> = { parse: resolveRequest };
 export const chartSeriesResolveOutputSchema: CapabilitySchema<ResolvedSeries> = { parse: resolvedOutput };
 
+/**
+ * Set on the capabilities registered series resolve through. The composer
+ * searches those series in the series registry, so capability search skips them.
+ */
+export const REGISTERED_SERIES_SOURCE_ID = "registered-series";
+
 export function chartSeriesCapabilityManifests(invoker: CapabilityInvoker) {
   return invoker.capabilityManifests(CHART_SERIES_CAPABILITY_KIND);
 }
 
+function searchableChartSeriesManifests(invoker: CapabilityInvoker) {
+  return chartSeriesCapabilityManifests(invoker).filter((manifest) => manifest.sourceId !== REGISTERED_SERIES_SOURCE_ID);
+}
+
 export async function searchChartSeriesCapabilities(
   invoker: CapabilityInvoker,
   query: string,
   limit = 8,
   signal?: AbortSignal,
 ): Promise<Array<ChartSeriesCatalogItem & { capabilityId: string; capabilityName: string }>> {
-  const manifests = chartSeriesCapabilityManifests(invoker);
+  const manifests = searchableChartSeriesManifests(invoker);
   const results = await Promise.allSettled(manifests.map(async (manifest) => {
     const items = await invoker.invokeCapability<ChartSeriesCatalogItem[]>(
       manifest.id,

package/src/capabilities/registry.ts

@@ -159,7 +159,14 @@ export class CapabilityRegistry {
 
   private resolveOperation(capabilityId: string, operationId: string, options: { renderer?: boolean }) {
     const entry = this.capabilities.get(capabilityId);
-    if (!entry || !this.isEnabled(entry)) throw new Error(`Capability "${capabilityId}" is not available.`);
+    if (!entry || !this.isEnabled(entry)) {
+      const pluginName = entry && this.options.isPluginEnabled?.(entry.pluginId) === false
+        ? this.options.pluginName?.(entry.pluginId)
+        : undefined;
+      throw new Error(pluginName
+        ? `Turn on ${pluginName} to use ${entry!.capability.name}.`
+        : `Capability "${capabilityId}" is not available.`);
+    }
     const operation = entry.capability.operations[operationId];
     if (!operation) throw new Error(`Capability operation "${capabilityId}.${operationId}" is not available.`);
     if (options.renderer && operation.rendererSafe !== true) {

package/src/capabilities/types.ts

@@ -132,6 +132,8 @@ export interface CapabilityManifest {
 
 export interface CapabilityRegistryOptions {
   isPluginEnabled?(pluginId: string): boolean;
+  /** Names the plugin a switched-off capability belongs to, so the error can say what to turn on. */
+  pluginName?(pluginId: string): string | undefined;
   isCapabilityEnabled?(capability: PluginCapability, pluginId: string): boolean;
   connectionHealth?: ConnectionHealthRegistry;
 }

package/src/cli/commands/crypto-hints.ts

@@ -1,6 +1,8 @@
 import { isCryptoInstrumentType } from "../../tickers/search/ranking";
+import { isCryptoVenuePerpetual } from "../../tickers/instrument-kind";
 import type { Quote } from "../../types/financials";
 import { isCryptoPairSymbol } from "../../utils/crypto-pair";
+import { isNotATickerMessage } from "../not-a-ticker";
 
 /** Where a crypto pair that will not load can still be read. `fn CRYP` takes no argument. */
 export const CRYPTO_BOARD_HINT = "Crypto prices may be briefly unavailable; the CRYP function (gloomberb fn CRYP) shows the crypto board.";
@@ -42,11 +44,15 @@ interface QuoteNoteResult {
   error: string | null;
 }
 
-/** The router words a failure as "<reason> for <symbol>"; drop the symbol so equal reasons group. */
+/**
+ * The router words a failure as "<reason> for <symbol>"; drop the symbol so equal reasons group.
+ * Any other line, such as a sentence the data service wrote, is kept as it reads.
+ */
 function failureReason(message: string, symbol: string): string {
-  const line = (message.split("\n")[0] ?? "").trim().replace(/\.+$/, "");
+  const line = (message.split("\n")[0] ?? "").trim();
+  const bare = line.replace(/\.+$/, "");
   const suffix = ` for ${symbol}`;
-  return line.toLowerCase().endsWith(suffix.toLowerCase()) ? line.slice(0, -suffix.length) : line;
+  return bare.toLowerCase().endsWith(suffix.toLowerCase()) ? bare.slice(0, -suffix.length) : line;
 }
 
 /**
@@ -63,7 +69,10 @@ export function quoteNotes(results: QuoteNoteResult[], options: { exchange?: str
     if (!symbols.includes(result.target.symbol)) failures.set(reason, [...symbols, result.target.symbol]);
   }
   const notes = [...failures].map(([reason, symbols]) => (
-    `${symbols.join(", ")}: ${reason}${symbols.some(isCryptoPairSymbol) ? `. ${CRYPTO_BOARD_HINT}` : ""}`
+    // "Not a ticker: APPLE." already names its symbol.
+    isNotATickerMessage(reason)
+      ? reason
+      : `${symbols.join(", ")}: ${reason}${symbols.some(isCryptoPairSymbol) ? `${/[.!?]$/.test(reason) ? "" : "."} ${CRYPTO_BOARD_HINT}` : ""}`
   ));
   if (!options.exchange) {
     for (const result of results) {
@@ -71,5 +80,11 @@ export function quoteNotes(results: QuoteNoteResult[], options: { exchange?: str
       if (note) notes.push(note);
     }
   }
+  const perpetuals = results
+    .filter((result) => result.quote && isCryptoVenuePerpetual(result.quote.instrumentType, result.quote.name))
+    .map((result) => result.target.symbol);
+  if (perpetuals.length > 0) {
+    notes.push(`${perpetuals.join(", ")}: perpetual futures ${perpetuals.length === 1 ? "price" : "prices"} on crypto venues, 24/7; not the listed future, not spot.`);
+  }
   return notes;
 }

package/src/cli/commands/fred-series.ts

@@ -0,0 +1,61 @@
+import { toBasisPoints } from "../../utils/basis-points";
+
+/** Where `fred` starts when `--start` is not given. */
+export const DEFAULT_FRED_START = "2021-01-01";
+
+/**
+ * FRED series that are spreads, which FRED serves in percentage points and
+ * rates desks read in basis points: `fred` text prints them in bp.
+ */
+const SPREAD_SERIES: ReadonlySet<string> = new Set([
+  "T10Y2Y", "T10Y3M",
+  "BAMLC0A0CM", "BAMLC0A1CAAA", "BAMLC0A2CAA", "BAMLC0A3CA", "BAMLC0A4CBBB", "BAMLH0A0HYM2",
+]);
+
+export function isSpreadSeries(seriesId: string): boolean {
+  return SPREAD_SERIES.has(seriesId.toUpperCase());
+}
+
+/** A spread in percentage points as the bp a text table prints: 0.44 is `44`, -0.125 is `-12.5`. */
+export function spreadBasisPointsCell(value: unknown): string {
+  return typeof value === "number" && Number.isFinite(value) ? String(toBasisPoints(value, 1)) : "";
+}
+
+/**
+ * Series FRED itself publishes late, with what a reader should know under the
+ * table. Add a series here when its newest FRED observation is not the newest
+ * reading the source has put out.
+ */
+const LAGGING_SERIES: Readonly<Record<string, string>> = {
+  UMCSENT: "FRED publishes the University of Michigan survey with a lag; latest preliminary reading: fn ECO",
+};
+
+export function laggingSeriesNote(seriesId: string): string | null {
+  return LAGGING_SERIES[seriesId.toUpperCase()] ?? null;
+}
+
+/**
+ * Where a series' history starts relative to what was asked for: the default
+ * start hides everything before it, and a start before the series begins
+ * silently begins later.
+ */
+export function fredHistoryNotes(input: {
+  startDate: string;
+  startGiven: boolean;
+  /** The series' first observation date, when FRED's metadata says. */
+  seriesStart: string | null | undefined;
+}): string[] {
+  const seriesStart = input.seriesStart && /^\d{4}-\d{2}-\d{2}$/.test(input.seriesStart) ? input.seriesStart : null;
+  if (!seriesStart) return [];
+  if (seriesStart > input.startDate) return [`Series begins ${seriesStart}.`];
+  return input.startGiven
+    ? []
+    : [`Showing from ${input.startDate}; earlier: --start YYYY-MM-DD (series begins ${seriesStart}).`];
+}
+
+/** What `fred` says when nothing falls on or after `--start`: where the series actually ends. */
+export function fredEmptyMessage(startDate: string, latest: { date: string; value: number | null } | null): string {
+  return latest
+    ? `Latest observation: ${latest.date}${latest.value == null ? "" : ` (${latest.value})`}. Nothing on or after ${startDate}.`
+    : "No results.";
+}