@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/components/ui/data-table/opentui/model.ts

@@ -1,5 +1,5 @@
 import { displayWidth } from "../../../../utils/format";
-import { tableColumnLeadGap } from "../../table-layout";
+import { fitTableCellText, tableColumnLeadGap } from "../../table-layout";
 
 /**
  * Where the viewport cuts a column: `inset` cells hidden on its left (past the
@@ -46,6 +46,31 @@ export function cutColumnText(
   return `${" ".repeat(start - clip.inset)}${body}${" ".repeat(shownEnd - end)}`;
 }
 
+/** A note uses only spare room: neither the label nor part of the note is cut to fit it. */
+export function fitColumnCellText(
+  text: string,
+  width: number,
+  align: string | undefined,
+  clip: DataTableColumnClip | null,
+  note?: string,
+): { text: string; note?: string; padding?: string } {
+  const fit = (value: string) => clip
+    ? cutColumnText(value, align, width, clip, (body, shown) => fitTableCellText(body, shown, align))
+    : width > 0 ? fitTableCellText(value, width, align) : "";
+  const combined = note ? `${text} ${note}` : "";
+  if (combined && displayWidth(combined) <= (clip?.width ?? width)) {
+    const fitted = fit(combined);
+    const start = fitted.indexOf(combined);
+    // A right-aligned value may fit the visible width but sit beyond its edge.
+    if (start >= 0) return {
+      text: fitted.slice(0, start + text.length + 1),
+      note,
+      padding: fitted.slice(start + combined.length),
+    };
+  }
+  return { text: fit(text) };
+}
+
 function sameClip(a: DataTableColumnClip | null, b: DataTableColumnClip | null): boolean {
   return a === b || (a !== null && b !== null && a.inset === b.inset && a.width === b.width);
 }

package/src/components/ui/data-table/types.ts

@@ -24,6 +24,8 @@ export type DataTableColumn = Pick<
 
 export interface DataTableCell {
   text: string;
+  /** Muted context after `text`, shown whole only when both fit on one line. Does not change the exported value. */
+  note?: string;
   /**
    * What CSV export writes instead of `text`: the full-precision number behind
    * it (3.45 for +3.45%, 1234567890 for 1.23B), or a date as an ISO string or

package/src/components/ui/display.tsx

@@ -7,6 +7,7 @@ import { Box, Text, TextAttributes, useUiCapabilities } from "../../ui";
 import { truncateToDisplayWidth } from "../../utils/format";
 import { CountryFlagLead } from "./country-flag";
 import { usePaneLinkMenuEntry } from "./external-link";
+import { ICON_GLYPHS, Icon, type IconName } from "./icon";
 import { titleCase } from "./header-case";
 import { statToneColor, type StatTone } from "./stat-grid";
 
@@ -199,6 +200,10 @@ export interface BadgeProps {
   /** For a domain scale, such as a sentiment score or chart series. */
   color?: string;
   variant?: "subtle" | "solid";
+  /** A mark before the label, in its colour: an SVG on the desktop, its glyph in the terminal. */
+  icon?: IconName;
+  /** False for a label that is not English to translate, such as a username. */
+  translate?: boolean;
 }
 
 /**
@@ -210,8 +215,9 @@ export const NATIVE_BADGE_STYLE = { height: "calc(100% - 2px)", borderRadius: "v
 /** How far a subtle chip's fill is tinted toward its tone. */
 export const BADGE_TINT = 0.28;
 const NATIVE_BADGE_TEXT_STYLE = { fontWeight: "var(--gloom-weight-regular)" };
+const NATIVE_ICON_BADGE_STYLE = { ...NATIVE_BADGE_STYLE, gap: "var(--gloom-space-xs)" };
 
-export function Badge({ label, tone = "neutral", color, variant = "subtle" }: BadgeProps) {
+export function Badge({ label, tone = "neutral", color, variant = "subtle", icon, translate = true }: BadgeProps) {
   const colors = useThemeColors();
   const { nativePaneChrome } = useUiCapabilities();
   const accent = color ?? (tone === "neutral" ? colors.textDim : tone === "accent" ? colors.borderFocused : colors[tone]);
@@ -220,10 +226,19 @@ export function Badge({ label, tone = "neutral", color, variant = "subtle" }: Ba
   const background = neutral ? colors.selected : solid ? accent : blendHex(colors.bg, accent, BADGE_TINT);
   const baseForeground = neutral ? colors.selectedText : solid ? colors.bg : accent;
   const foreground = blendForContrast(baseForeground, background, higherContrast("#000000", "#ffffff", background), 4.5);
+  const text = translate ? t(label) : label;
+  const nativeIcon = nativePaneChrome && icon;
+  // The terminal draws the icon's glyph as text in front of the label.
+  const shown = icon && !nativePaneChrome ? [ICON_GLYPHS[icon], text].filter(Boolean).join(" ") : text;
   const chip = (
     <Box height={nativePaneChrome ? undefined : 1} paddingX={1} backgroundColor={background}
-      data-gloom-ui="badge" justifyContent={nativePaneChrome ? "center" : undefined} style={nativePaneChrome ? NATIVE_BADGE_STYLE : undefined}>
-      <Text fg={foreground} attributes={TextAttributes.BOLD} style={nativePaneChrome ? NATIVE_BADGE_TEXT_STYLE : undefined}>{t(label)}</Text>
+      data-gloom-ui="badge" {...(nativeIcon ? { flexDirection: "row", alignItems: "center" } as const : {})}
+      justifyContent={nativePaneChrome && !icon ? "center" : undefined}
+      style={nativePaneChrome ? icon ? NATIVE_ICON_BADGE_STYLE : NATIVE_BADGE_STYLE : undefined}>
+      {nativeIcon ? <Icon name={nativeIcon} color={foreground} /> : null}
+      {shown || !nativeIcon ? (
+        <Text fg={foreground} attributes={TextAttributes.BOLD} style={nativePaneChrome ? NATIVE_BADGE_TEXT_STYLE : undefined}>{shown}</Text>
+      ) : null}
     </Box>
   );
   return nativePaneChrome ? <Box height={1} flexShrink={0} justifyContent="center">{chip}</Box> : chip;

package/src/components/ui/icon.tsx

@@ -38,7 +38,8 @@ export type IconName =
   | "team"
   | "pro"
   | "clock"
-  | "edit";
+  | "edit"
+  | "mail";
 
 /** Terminal glyph for each icon; the desktop host draws SVG. */
 export const ICON_GLYPHS: Record<IconName, string> = {
@@ -84,6 +85,8 @@ export const ICON_GLYPHS: Record<IconName, string> = {
   // Time, for data that arrives late (a delayed quote).
   clock: "◷",
   edit: "✎",
+  // A message written to you (a DM): text presentation, one cell.
+  mail: "✉",
 };
 
 export interface IconProps {

package/src/components/ui/list-view.tsx

@@ -15,6 +15,7 @@ export interface ListViewItem {
   description?: string;
   detail?: string;
   category?: string;
+  /** `heading` draws a muted group label; pair it with `disabled: true`. */
   kind?: string;
   right?: string;
   checked?: boolean;
@@ -148,6 +149,7 @@ function DefaultRow({
   selected: boolean;
 }) {
   const colors = useThemeColors();
+  if (item.kind === "heading") return <Text fg={colors.textMuted}>{t(item.label)}</Text>;
   // The label gives way to the detail: a long label is cut with an ellipsis
   // instead of wrapping under the row or running into the right column.
   return (
@@ -289,6 +291,7 @@ export function ListView({
   const rowHoverBg = hoverBgColor ?? hoverBg(colors);
   const selectedItem = selectedIndex >= 0 ? items[selectedIndex] : undefined;
   const activeScrollIndex = scrollIndex ?? selectedIndex;
+  const headingAboveSelection = items[activeScrollIndex - 1]?.kind === "heading";
   const terminalRowHeight = rowHeight ?? 1;
   const terminalRowGap = rowGap ?? 0;
   const rowStride = terminalRowHeight + terminalRowGap;
@@ -299,13 +302,14 @@ export function ListView({
     if (!sb) return;
     const safeIndex = Math.min(activeScrollIndex, items.length - 1);
     const viewportH = Math.max(sb.viewport?.height ?? 1, 1);
-    const rowTop = safeIndex * rowStride;
+    const rowTop = Math.max(0, safeIndex - (headingAboveSelection ? 1 : 0)) * rowStride;
+    const rowBottom = safeIndex * rowStride + terminalRowHeight;
     if (rowTop < sb.scrollTop) {
       sb.scrollTo(rowTop);
-    } else if (rowTop + terminalRowHeight > sb.scrollTop + viewportH) {
-      sb.scrollTo(rowTop + terminalRowHeight - viewportH);
+    } else if (rowBottom > sb.scrollTop + viewportH) {
+      sb.scrollTo(rowBottom - viewportH);
     }
-  }, [activeScrollIndex, autoScrollToIndex, items.length, rowStride, scrollable, terminalRowHeight]);
+  }, [activeScrollIndex, autoScrollToIndex, headingAboveSelection, items.length, rowStride, scrollable, terminalRowHeight]);
   useEffect(revealActiveRow, [revealActiveRow]);
   // A list that opens on a row past the fold has nothing to scroll until its
   // first computed layout sizes the viewport and the rows.

package/src/components/ui/query-bar-keys.tsx

@@ -12,6 +12,7 @@ import type { QueryBarFilter, QueryBarSearch, QueryBarView } from "./query-bar";
 interface ChoiceOption {
   value: string;
   label: string;
+  group?: string;
   description?: string;
   disabled?: boolean;
   color?: string;
@@ -70,6 +71,7 @@ export function useQueryBarKeys({
           choices={options.map((option) => ({
             id: option.value,
             label: option.label,
+            group: option.group,
             description: option.description,
             disabled: option.disabled,
             color: option.color,

package/src/components/ui/query-bar.tsx

@@ -417,6 +417,7 @@ export function QueryBar({ width, search, filters = [], view, meta: given, asOf,
       options: filter.options.map((option) => ({
         value: option.value,
         label: option.label,
+        group: option.group,
         description: option.description,
         disabled: option.disabled,
         selected: option.value === filter.value,

package/src/components/ui/select-button.tsx

@@ -18,6 +18,8 @@ export interface SelectControl {
 export interface SelectButtonOption<T extends string = string> {
   value: T;
   label: string;
+  /** Heading for a contiguous group of choices; never selectable itself. */
+  group?: string;
   /** Trigger wording when the full label is too wide for a pane header. */
   short?: string;
   description?: string;
@@ -130,6 +132,7 @@ export function SelectButton<T extends string = string>({
           choices={options.map((option) => ({
             id: option.value,
             label: option.label,
+            group: option.group,
             description: option.description,
             disabled: option.disabled,
             color: option.color,
@@ -158,7 +161,7 @@ export function SelectButton<T extends string = string>({
           selectRef={(element) => { selectFieldRef.current = element; }}
           onFocus={onFocus}
           value={value}
-          options={options.map((option) => ({ value: option.value, label: option.label, disabled: option.disabled }))}
+          options={options.map((option) => ({ value: option.value, label: option.label, group: option.group, disabled: option.disabled }))}
           disabled={disabled}
           onChange={selectValue}
         />
@@ -180,6 +183,7 @@ export function SelectButton<T extends string = string>({
           options={options.map((option) => ({
             value: option.value,
             label: option.label,
+            group: option.group,
             disabled: option.disabled,
           }))}
           disabled={disabled}

package/src/components/ui/select-field.tsx

@@ -9,6 +9,7 @@ export interface SelectFieldHandle {
 
 interface SelectFieldOption {
   label: string;
+  group?: string;
   value: string;
   description?: string;
   disabled?: boolean;

package/src/components/ui/table-layout.ts

@@ -106,18 +106,21 @@ export function getTableWidth(
  * The columns that fit in `width` cells: whole columns in `dropOrder` (least
  * needed first) give way until the rest fit, rather than the table's right
  * edge cutting a value, so a narrow pane drops a name that repeats its ticker
- * before it cuts a date. Columns not listed stay at every width. A table that
- * scrolls vertically passes its width less the scrollbar's cell.
+ * before it cuts a date. An entry that lists several ids drops them together,
+ * for columns that mean little apart (a bid's venue and an ask's). Columns not
+ * listed stay at every width. A table that scrolls vertically passes its width
+ * less the scrollbar's cell.
  */
 export function dropColumnsToFit<C extends TableWidthColumn & { id: string }>(
   columns: readonly C[],
   width: number,
-  dropOrder: readonly string[],
+  dropOrder: readonly (string | readonly string[])[],
 ): C[] {
   let shown = [...columns];
-  for (const id of dropOrder) {
+  for (const step of dropOrder) {
     if (getTableWidth(shown) <= width) break;
-    shown = shown.filter((column) => column.id !== id);
+    const ids = typeof step === "string" ? [step] : step;
+    shown = shown.filter((column) => !ids.includes(column.id));
   }
   return shown;
 }

package/src/core/app-runtime.ts

@@ -1,5 +1,6 @@
 import { MarketDataCoordinator, getSharedMarketDataCoordinator, setSharedMarketDataCoordinator } from "../market-data/coordinator";
 import { NewsService, type NewsServiceOptions } from "../news/aggregator";
+import { cloudNewsSession } from "../news/cloud-session";
 import { getSharedNewsService, setSharedNewsService } from "../news/hooks";
 import { PluginRegistry } from "../plugins/registry";
 import { releaseSharedRegistry } from "../plugins/registry/shared";
@@ -61,6 +62,7 @@ export function createAppRuntime({
   const newsService = new NewsService({
     connectionHealth: pluginRegistry.connectionHealth,
     pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60_000,
+    session: cloudNewsSession,
     ...newsOptions,
   });
   const modules = { pluginRegistry, marketData, newsService };

package/src/core/app-services.ts

@@ -27,8 +27,8 @@ export function createAppServices({ config, plugins, externalPlugins }: AppServi
           provider: {
             fetchNews: async (query) => (await newsService.load(query)).articles,
             fetchNewsPage: async (query) => {
-              const { articles, error, nextCursor } = await newsService.load(query);
-              return { articles, error, nextCursor };
+              const { articles, error, nextCursor, access } = await newsService.load(query);
+              return { articles, error, nextCursor, access };
             },
             getCachedNews: (query) => newsService.getQueryState(query).articles,
           },

package/src/data/config/chart-settings.ts

@@ -20,7 +20,7 @@ import {
 import { recordOrNull } from "../../utils/guards";
 
 const CHART_RANGES = new Set<TimeRange>(TIME_RANGES);
-const PRICE_RENDER_MODES = new Set<SeriesStyle>(["area", "line", "candles", "ohlc", "hlc"]);
+const PRICE_RENDER_MODES = new Set<SeriesStyle>(["area", "line", "candles", "hollow", "heikin-ashi", "ohlc", "hlc"]);
 const LEGACY_INDICATOR_IDS = new Set<LegacyChartIndicatorId>([
   "volume",
   "sma20",

package/src/data/json-ticker-repository.ts

@@ -4,6 +4,7 @@ import { hydrateTickerMetadata } from "../tickers/metadata";
 import type { TickerMetadata, TickerRecord } from "../types/ticker";
 import { BROWSER_STORAGE_KEYS, SafeJsonStorage, type StorageLike } from "./json-storage";
 import { isRecord } from "../utils/guards";
+import { runTickerWrite } from "./ticker-writes";
 
 type StoredTickers = Record<string, TickerMetadata>;
 
@@ -39,20 +40,28 @@ export class JsonTickerRepository implements AppTickerRepositoryPort {
     return metadata ? hydrate(metadata) : null;
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
+  private writeTicker(ticker: TickerRecord): void {
     const symbol = normalizeSymbol(ticker.metadata.ticker);
     this.data.set({ ...this.data.get(), [symbol]: ticker.metadata });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, () => this.writeTicker(ticker));
+  }
+
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, () => {
+      this.writeTicker(ticker);
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    const tickers = { ...this.data.get() };
-    delete tickers[normalizeSymbol(symbol)];
-    this.data.set(tickers);
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, () => {
+      const tickers = { ...this.data.get() };
+      delete tickers[normalizeSymbol(symbol)];
+      this.data.set(tickers);
+    });
   }
 }

package/src/data/plugin-cache.ts

@@ -108,11 +108,13 @@ export function createPluginCache<T, Stored = T>(options: {
         }
         return { value, fetchedAt, staleAt: fetchedAt + options.policy.staleMs, expiresAt: fetchedAt + options.policy.expireMs, source: options.source };
       } });
+      // A retained copy carries its refresh failure, whatever was thrown (an Error without a message included).
+      const failed = "refreshError" in result;
       const error = result.refreshError;
       return {
-        data: result.value, fetchedAt: result.fetchedAt, stale: !!error || result.staleAt <= Date.now(),
-        source: error ? "stale-fallback" : result === before ? "cache" : "network",
-        ...(error ? { error, refreshError: error instanceof Error ? error.message : String(error) } : {}),
+        data: result.value, fetchedAt: result.fetchedAt, stale: failed || result.staleAt <= Date.now(),
+        source: failed ? "stale-fallback" : result === before ? "cache" : "network",
+        ...(failed ? { error, refreshError: error instanceof Error ? error.message : String(error) } : {}),
       };
     },
   };

package/src/data/saved-copies.ts

@@ -56,6 +56,14 @@ export function savedCopyMark(value: unknown): object {
   return savedAt != null ? { [SAVED_AT]: savedAt } : {};
 }
 
+/**
+ * The refresh failure a command still prints for `result`: none when a saved
+ * copy answered for it (`servedFromSavedCopy`), whose closing line says so.
+ */
+export function unansweredRefreshError(result: { refreshError?: string | null } | null | undefined): string | null {
+  return result?.refreshError && savedCopyAt(result) == null ? result.refreshError : null;
+}
+
 /** When `value` itself was saved, if it is a saved copy served after a failed refresh; null otherwise. */
 export function savedCopyAt(value: unknown): number | null {
   const savedAt = value && typeof value === "object" ? (value as Marked)[SAVED_AT] : undefined;

package/src/data/ticker-repository.ts

@@ -2,6 +2,7 @@ import { logFailure } from "../utils/log-failure";
 import type { TickerRecord, TickerMetadata } from "../types/ticker";
 import type { TickerStore } from "./ticker-store";
 import { hydrateTickerMetadata } from "../tickers/metadata";
+import { runTickerWrite } from "./ticker-writes";
 
 function parseTickerMetadata(json: string): TickerMetadata {
   return hydrateTickerMetadata(JSON.parse(json) as Record<string, unknown>);
@@ -32,22 +33,28 @@ export class TickerRepository {
     }
   }
 
-  async saveTicker(ticker: TickerRecord): Promise<void> {
-    this.tickers.save(ticker.metadata.ticker, ticker.metadata);
+  saveTicker(ticker: TickerRecord): Promise<void> {
+    return runTickerWrite(this, ticker.metadata.ticker, () => {
+      this.tickers.save(ticker.metadata.ticker, ticker.metadata);
+    });
   }
 
   /** Saves several tickers in one write. */
-  async saveTickers(tickers: readonly TickerRecord[]): Promise<void> {
-    this.tickers.saveMany(tickers.map((ticker) => ({ symbol: ticker.metadata.ticker, metadata: ticker.metadata })));
+  saveTickers(tickers: readonly TickerRecord[]): Promise<void> {
+    return runTickerWrite(this, tickers.map((ticker) => ticker.metadata.ticker), () => {
+      this.tickers.saveMany(tickers.map((ticker) => ({ symbol: ticker.metadata.ticker, metadata: ticker.metadata })));
+    });
   }
 
-  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+  createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
     const ticker: TickerRecord = { metadata };
-    await this.saveTicker(ticker);
-    return ticker;
+    return runTickerWrite(this, metadata.ticker, () => {
+      this.tickers.save(metadata.ticker, metadata);
+      return ticker;
+    });
   }
 
-  async deleteTicker(symbol: string): Promise<void> {
-    this.tickers.delete(symbol);
+  deleteTicker(symbol: string): Promise<void> {
+    return runTickerWrite(this, symbol, () => this.tickers.delete(symbol));
   }
 }

package/src/data/ticker-writes.ts

@@ -0,0 +1,81 @@
+interface TickerWrites {
+  revisions: Map<string, number>;
+  tails: Map<string, Promise<unknown>>;
+  pending: Set<Promise<unknown>>;
+}
+
+const repositories = new WeakMap<object, TickerWrites>();
+
+function writesFor(repository: object): TickerWrites {
+  let writes = repositories.get(repository);
+  if (!writes) {
+    writes = { revisions: new Map(), tails: new Map(), pending: new Set() };
+    repositories.set(repository, writes);
+  }
+  return writes;
+}
+
+function tickerKey(symbol: string): string {
+  return symbol.trim().toUpperCase();
+}
+
+/** Reserve writes when requested, including ones waiting for an earlier acknowledgement. */
+export function runTickerWrite<Result>(
+  repository: object,
+  symbols: string | readonly string[],
+  write: () => Result | PromiseLike<Result>,
+): Promise<Result> {
+  const writes = writesFor(repository);
+  const keys = [...new Set((typeof symbols === "string" ? [symbols] : symbols).map(tickerKey))];
+  const previous = [...new Set(keys.flatMap((key) => {
+    const tail = writes.tails.get(key);
+    return tail ? [tail] : [];
+  }))];
+  let resolve!: (value: Result | PromiseLike<Result>) => void;
+  let reject!: (error: unknown) => void;
+  const result = new Promise<Result>((accept, fail) => {
+    resolve = accept;
+    reject = fail;
+  });
+  for (const key of keys) {
+    writes.revisions.set(key, (writes.revisions.get(key) ?? 0) + 1);
+    writes.tails.set(key, result);
+  }
+  writes.pending.add(result);
+  const finished = () => {
+    writes.pending.delete(result);
+    for (const key of keys) {
+      if (writes.tails.get(key) === result) writes.tails.delete(key);
+    }
+  };
+  void result.then(finished, finished);
+  const start = () => {
+    try {
+      resolve(write());
+    } catch (error) {
+      reject(error);
+    }
+  };
+  if (previous.length) void Promise.allSettled(previous).then(start);
+  else start();
+  return result;
+}
+
+/** Changes immediately when a save or deletion is requested, before its acknowledgement. */
+export function tickerWriteRevision(repository: object, symbol: string): number {
+  return repositories.get(repository)?.revisions.get(tickerKey(symbol)) ?? 0;
+}
+
+/** Whether a write arrived after a caller last waited for acknowledgements. */
+export function hasPendingTickerWrites(repository: object): boolean {
+  return (repositories.get(repository)?.pending.size ?? 0) > 0;
+}
+
+/** Let save-await callers publish their edits before cleanup reads the current rows. */
+export async function settleTickerWrites(repository: object): Promise<void> {
+  const writes = writesFor(repository);
+  do {
+    // Each writer handles its own failure; cleanup still needs the last published row.
+    await Promise.allSettled([...writes.pending]);
+  } while (writes.pending.size);
+}