gloomberb 0.3.7 → 0.4.0

package/src/types/financials.ts

@@ -1,4 +1,21 @@
 export type MarketState = "PRE" | "REGULAR" | "POST" | "PREPRE" | "POSTPOST" | "CLOSED";
+export type SessionConfidence = "explicit" | "derived" | "unknown";
+export type QuoteDataSource = "live" | "delayed" | "yahoo";
+
+export interface QuoteFieldProvenance {
+  providerId: string;
+  dataSource?: QuoteDataSource;
+}
+
+export interface QuoteProvenance {
+  price?: QuoteFieldProvenance;
+  session?: QuoteFieldProvenance;
+  listing?: QuoteFieldProvenance;
+  routing?: QuoteFieldProvenance;
+  descriptive?: QuoteFieldProvenance;
+  fields?: Record<string, QuoteFieldProvenance>;
+  rejectedPriceProviders?: string[];
+}
 
 export interface Quote {
   symbol: string;
@@ -16,7 +33,12 @@ export interface Quote {
   lastUpdated: number; // timestamp ms
   exchangeName?: string;
   fullExchangeName?: string;
+  listingExchangeName?: string;
+  listingExchangeFullName?: string;
+  routingExchangeName?: string;
+  routingExchangeFullName?: string;
   marketState?: MarketState;
+  sessionConfidence?: SessionConfidence;
   preMarketPrice?: number;
   preMarketChange?: number;
   preMarketChangePercent?: number;
@@ -31,10 +53,17 @@ export interface Quote {
   high?: number;
   low?: number;
   mark?: number;
+  provenance?: QuoteProvenance;
   /** Where the quote data came from: live broker feed, delayed broker feed, or a fallback like Yahoo. */
-  dataSource?: "live" | "delayed" | "yahoo";
+  dataSource?: QuoteDataSource;
 }
 
+export interface QuoteContribution extends Quote {
+  providerId: string;
+}
+
+export type QuoteContributionMap = Record<string, QuoteContribution>;
+
 export interface Fundamentals {
   trailingPE?: number;
   forwardPE?: number;
@@ -110,6 +139,7 @@ export interface PricePoint {
 
 export interface TickerFinancials {
   quote?: Quote;
+  quoteContributions?: QuoteContributionMap;
   fundamentals?: Fundamentals;
   profile?: CompanyProfile;
   annualStatements: FinancialStatement[];

package/src/types/plugin.ts

@@ -169,6 +169,75 @@ export interface WizardStep {
   body?: string[];
 }
 
+export interface CliHelpColumn {
+  header: string;
+  align?: "left" | "right" | "center";
+  width?: number;
+}
+
+export interface CliCommandHelpSection {
+  title: string;
+  columns?: CliHelpColumn[];
+  rows?: string[][];
+  lines?: string[];
+}
+
+export interface CliCommandHelp {
+  usage?: string[];
+  sections?: CliCommandHelpSection[];
+}
+
+export interface CliLaunchEnvironment {
+  terminalWidth: number;
+  terminalHeight: number;
+}
+
+export interface CliLaunchConfigResult<TLaunchState = unknown> {
+  config: AppConfig;
+  launchState?: TLaunchState;
+}
+
+export interface CliLaunchRequest<TLaunchState = unknown> {
+  applyConfig(config: AppConfig, env: CliLaunchEnvironment): CliLaunchConfigResult<TLaunchState>;
+  applySessionSnapshot?(
+    config: AppConfig,
+    snapshot: import("../state/session-persistence").AppSessionSnapshot | null,
+    launchState: TLaunchState | undefined,
+  ): import("../state/session-persistence").AppSessionSnapshot;
+}
+
+export type CliDispatchResult =
+  | { kind: "handled" }
+  | { kind: "launch-ui"; request: CliLaunchRequest }
+  | { kind: "unhandled" };
+
+export interface CliCommandContext {
+  initConfigData(): Promise<import("../cli/types").ConfigContext>;
+  initMarketData(): Promise<import("../cli/types").MarketContext>;
+  fail(message: string, details?: string): never;
+  closeAndFail(
+    persistence: import("../data/app-persistence").AppPersistence,
+    message: string,
+    details?: string,
+  ): never;
+  output: {
+    cliStyles: typeof import("../utils/cli-output").cliStyles;
+    colorBySign: typeof import("../utils/cli-output").colorBySign;
+    renderSection: typeof import("../utils/cli-output").renderSection;
+    renderStat: typeof import("../utils/cli-output").renderStat;
+    renderTable: typeof import("../utils/cli-output").renderTable;
+  };
+  log: PluginLogger;
+}
+
+export interface CliCommandDef {
+  name: string;
+  aliases?: string[];
+  description: string;
+  help?: CliCommandHelp;
+  execute(args: string[], ctx: CliCommandContext): void | CliDispatchResult | Promise<void | CliDispatchResult>;
+}
+
 export interface CommandDef {
   id: string;
   label: string;
@@ -340,6 +409,7 @@ export interface GloomPlugin {
   description?: string;
   toggleable?: boolean;
   order?: number;
+  cliCommands?: CliCommandDef[];
 
   setup?(ctx: GloomPluginContext): void | Promise<void>;
   dispose?(): void;

package/src/utils/api-client.test.ts

@@ -84,3 +84,60 @@ describe("apiClient auth cookies", () => {
     ]);
   });
 });
+
+describe("apiClient chat timestamps", () => {
+  test("normalizes transcript and send-response timestamps to UTC ISO strings", async () => {
+    const responses = [
+      createResponse([{
+        id: "m1",
+        channelId: "everyone",
+        content: "older",
+        replyToId: null,
+        createdAt: "2026-04-08 07:28:27.625",
+        user: { id: "u1", username: "alice", displayName: "Alice" },
+        replyTo: null,
+      }]),
+      createResponse({
+        id: "m2",
+        channelId: "everyone",
+        content: "hello",
+        replyToId: null,
+        createdAt: "2026-04-08T07:29:27.625",
+        user: { id: "u1", username: "alice", displayName: "Alice" },
+        replyTo: null,
+      }),
+    ];
+
+    globalThis.fetch = (async () => responses.shift() as Response) as typeof fetch;
+
+    const messages = await apiClient.getMessages("everyone", { limit: 1 });
+    const sentMessage = await apiClient.sendMessage("everyone", "hello");
+
+    expect(messages[0]?.createdAt).toBe("2026-04-08T07:28:27.625Z");
+    expect(sentMessage.createdAt).toBe("2026-04-08T07:29:27.625Z");
+  });
+
+  test("normalizes websocket chat timestamps before notifying listeners", async () => {
+    const seenCreatedAts: string[] = [];
+    const channel = apiClient.connectChannel("everyone", (message) => {
+      seenCreatedAts.push(message.createdAt);
+    });
+
+    await (apiClient as any).handleSocketMessage(JSON.stringify({
+      type: "chat.message",
+      channelId: "everyone",
+      data: {
+        id: "m1",
+        channelId: "everyone",
+        content: "hello",
+        replyToId: null,
+        createdAt: "2026-04-08 07:28:27.625",
+        user: { id: "u1", username: "alice", displayName: "Alice" },
+        replyTo: null,
+      },
+    }));
+
+    expect(seenCreatedAts).toEqual(["2026-04-08T07:28:27.625Z"]);
+    channel.close();
+  });
+});

package/src/utils/api-client.ts

@@ -1,6 +1,7 @@
 import type { CompanyProfile, Fundamentals, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { debugLog } from "./debug-log";
+import { normalizeTimestamp } from "./timestamp";
 
 const DEFAULT_API_URL = "https://api.gloom.sh";
 const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
@@ -14,6 +15,8 @@ export interface ChatMessage {
   createdAt: string;
   user: { id: string; username: string; displayName: string };
   replyTo?: { content: string; user: { username: string } } | null;
+  clientStatus?: "sending" | "failed";
+  clientError?: string | null;
 }
 
 export interface ChatChannel {
@@ -106,6 +109,17 @@ function marketKey(symbol: string, exchange?: string): string {
   return normalizedExchangeValue ? `${normalizedSymbolValue}:${normalizedExchangeValue}` : normalizedSymbolValue;
 }
 
+function normalizeChatMessage(message: ChatMessage): ChatMessage {
+  return {
+    ...message,
+    createdAt: normalizeTimestamp(message.createdAt),
+  };
+}
+
+function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
+  return messages.map((message) => normalizeChatMessage(message));
+}
+
 type ChannelListener = (message: ChatMessage) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
 type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
@@ -404,8 +418,9 @@ class GloomApiClient {
     }
 
     if (parsed?.type === "chat.message" && typeof parsed.channelId === "string" && parsed.data) {
+      const message = normalizeChatMessage(parsed.data as ChatMessage);
       for (const listener of this.channelListeners.get(parsed.channelId) ?? []) {
-        listener(parsed.data as ChatMessage);
+        listener(message);
       }
       return;
     }
@@ -491,23 +506,30 @@ class GloomApiClient {
     if (opts?.before) params.set("before", opts.before);
     if (opts?.limit) params.set("limit", String(opts.limit));
     const qs = params.toString();
-    return this.request<ChatMessage[]>(`/chat/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
+    const messages = await this.request<ChatMessage[]>(`/chat/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
+    return normalizeChatMessages(messages);
   }
 
   async sendMessage(channelId: string, content: string, replyToId?: string): Promise<ChatMessage> {
-    return this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
+    const message = await this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
       method: "POST",
       body: JSON.stringify({ content, replyToId }),
     });
+    return normalizeChatMessage(message);
   }
 
   connectChannel(
     channelId: string,
     onMessage: (msg: ChatMessage) => void,
     onError?: (err: string) => void,
-  ): { send: (content: string, replyToId?: string) => void; close: () => void } {
+  ): { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void } {
     if (!channelId) {
-      return { send: () => {}, close: () => {} };
+      return {
+        send: async () => {
+          throw new Error("Channel id is required");
+        },
+        close: () => {},
+      };
     }
 
     const listeners = this.channelListeners.get(channelId) ?? new Set<ChannelListener>();
@@ -520,14 +542,15 @@ class GloomApiClient {
     }
 
     return {
-      send: (content: string, replyToId?: string) => {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-          this.sendSocketMessage({ type: "chat.send", channelId, content, replyToId });
-          return;
-        }
-        void this.sendMessage(channelId, content, replyToId).then(onMessage).catch((error) => {
+      send: async (content: string, replyToId?: string) => {
+        try {
+          const message = await this.sendMessage(channelId, content, replyToId);
+          onMessage(message);
+          return message;
+        } catch (error) {
           onError?.(error instanceof Error ? error.message : String(error));
-        });
+          throw error;
+        }
       },
       close: () => {
         const current = this.channelListeners.get(channelId);

package/src/utils/back-navigation.ts

@@ -0,0 +1,27 @@
+export interface BackNavigationEventLike {
+  name?: string;
+  ctrl?: boolean;
+  meta?: boolean;
+  option?: boolean;
+  shift?: boolean;
+}
+
+export function isPlainBackspace(event: BackNavigationEventLike): boolean {
+  return event.name === "backspace"
+    && !event.ctrl
+    && !event.meta
+    && !event.option
+    && !event.shift;
+}
+
+export function isPlainEscape(event: BackNavigationEventLike): boolean {
+  return (event.name === "escape" || event.name === "esc")
+    && !event.ctrl
+    && !event.meta
+    && !event.option
+    && !event.shift;
+}
+
+export function isBackNavigationKey(event: BackNavigationEventLike): boolean {
+  return isPlainBackspace(event) || isPlainEscape(event);
+}

package/src/utils/format.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "bun:test";
+import { formatTimeAgo } from "./format";
+
+describe("formatTimeAgo", () => {
+  test("handles UTC ISO timestamps with explicit offsets", () => {
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60_000).toISOString().replace("Z", "+00:00");
+    expect(formatTimeAgo(fiveMinutesAgo)).toBe("5m ago");
+  });
+
+  test("treats space-separated chat timestamps without a timezone as UTC", () => {
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60_000).toISOString().replace("T", " ").replace("Z", "");
+    expect(formatTimeAgo(fiveMinutesAgo)).toBe("5m ago");
+  });
+});

package/src/utils/format.ts

@@ -1,3 +1,5 @@
+import { toTimestampMillis } from "./timestamp";
+
 const currencyFormatters = new Map<string, Intl.NumberFormat>();
 const numberFormatters = new Map<number, Intl.NumberFormat>();
 
@@ -143,9 +145,7 @@ export function convertCurrency(
 
 /** Format a date/timestamp as relative time (e.g., "5m ago", "2h ago") */
 export function formatTimeAgo(date: Date | string): string {
-  const ts = typeof date === "string"
-    ? new Date(date.endsWith("Z") ? date : date + "Z").getTime()
-    : date.getTime();
+  const ts = toTimestampMillis(date);
   const seconds = Math.floor((Date.now() - ts) / 1000);
   if (seconds < 60) return "just now";
   const minutes = Math.floor(seconds / 60);

package/src/utils/market-status.ts

@@ -1,4 +1,4 @@
-import type { MarketState, Quote } from "../types/financials";
+import type { MarketState, Quote, QuoteFieldProvenance } from "../types/financials";
 import { colors, priceColor } from "../theme/colors";
 import { formatPercentRaw } from "./format";
 
@@ -30,6 +30,22 @@ export function marketStateColor(state: MarketState): string {
   }
 }
 
+export function marketStateDot(state?: MarketState): string {
+  switch (state) {
+    case "REGULAR":
+      return "\u25CF";
+    case "PRE":
+    case "POST":
+      return "\u25D0";
+    case "CLOSED":
+    case "PREPRE":
+    case "POSTPOST":
+      return "\u25CB";
+    default:
+      return "\u25CC";
+  }
+}
+
 /** Short exchange display name */
 export function exchangeShortName(exchangeName?: string, fullExchangeName?: string): string {
   if (!exchangeName && !fullExchangeName) return "";
@@ -57,6 +73,35 @@ export function exchangeShortName(exchangeName?: string, fullExchangeName?: stri
   return map[name] || name;
 }
 
+export function quoteProviderLabel(providerId?: string): string {
+  switch (providerId) {
+    case "ibkr":
+      return "Broker";
+    case "gloomberb-cloud":
+      return "Cloud";
+    case "yahoo":
+      return "Yahoo";
+    default:
+      return providerId || "Unknown";
+  }
+}
+
+export function quoteSourceLabel(
+  provenance?: QuoteFieldProvenance,
+  kind: "price" | "session" = "price",
+): string {
+  if (!provenance?.providerId) return "Unknown";
+  if (provenance.providerId === "ibkr") {
+    if (kind === "session") return "Broker";
+    if (provenance.dataSource === "live") return "IBKR live";
+    if (provenance.dataSource === "delayed") return "IBKR delayed";
+    return "IBKR";
+  }
+  if (provenance.providerId === "gloomberb-cloud") return "Cloud";
+  if (provenance.providerId === "yahoo") return "Yahoo";
+  return provenance.providerId;
+}
+
 /** Get extended hours price info (pre-market or after-hours) for display */
 export function getExtendedHoursInfo(quote: Quote | null | undefined): { text: string; color: string } | null {
   if (!quote) return null;

package/src/utils/quote-freshness.ts

@@ -0,0 +1,127 @@
+import type { MarketState, Quote } from "../types/financials";
+
+const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
+const EXCHANGE_TIME_ZONES: Record<string, string> = {
+  NASDAQ: "America/New_York",
+  NYSE: "America/New_York",
+  ARCA: "America/New_York",
+  AMEX: "America/New_York",
+  BATS: "America/New_York",
+  FWB: "Europe/Berlin",
+  FWB2: "Europe/Berlin",
+  XETRA: "Europe/Berlin",
+  SWX: "Europe/Zurich",
+  SFB: "Europe/Stockholm",
+  HKEX: "Asia/Hong_Kong",
+  JPX: "Asia/Tokyo",
+  TPEX: "Asia/Taipei",
+  NSE: "Asia/Kolkata",
+  BSE: "Asia/Kolkata",
+  LSE: "Europe/London",
+};
+const EXCHANGE_ALIASES: Record<string, string> = {
+  NMS: "NASDAQ",
+  NGM: "NASDAQ",
+  NCM: "NASDAQ",
+  NAS: "NASDAQ",
+  NYQ: "NYSE",
+  NYS: "NYSE",
+  PCX: "AMEX",
+  ASE: "AMEX",
+  HKG: "HKEX",
+  GER: "XETRA",
+};
+
+type UsSessionState = Exclude<MarketState, never>;
+
+function normalizeExchange(exchange?: string): string {
+  const normalized = (exchange ?? "").trim().toUpperCase();
+  return EXCHANGE_ALIASES[normalized] ?? normalized;
+}
+
+function isUsExtendedHoursExchange(exchange?: string): boolean {
+  return US_EXTENDED_HOURS_EXCHANGES.has(normalizeExchange(exchange));
+}
+
+function exchangeLocalDate(exchange: string, timestampMs: number): string | null {
+  const timeZone = EXCHANGE_TIME_ZONES[normalizeExchange(exchange)];
+  if (!timeZone) return null;
+
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(new Date(timestampMs));
+  const year = parts.find((part) => part.type === "year")?.value;
+  const month = parts.find((part) => part.type === "month")?.value;
+  const day = parts.find((part) => part.type === "day")?.value;
+  if (!year || !month || !day) return null;
+  return `${year}-${month}-${day}`;
+}
+
+function usSessionState(timestampMs: number): UsSessionState {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/New_York",
+    weekday: "short",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23",
+  }).formatToParts(new Date(timestampMs));
+
+  const weekday = parts.find((part) => part.type === "weekday")?.value ?? "";
+  if (weekday === "Sat" || weekday === "Sun") return "CLOSED";
+
+  const hour = Number(parts.find((part) => part.type === "hour")?.value ?? "0");
+  const minute = Number(parts.find((part) => part.type === "minute")?.value ?? "0");
+  const totalMinutes = hour * 60 + minute;
+
+  if (totalMinutes < 4 * 60) return "PREPRE";
+  if (totalMinutes < 9 * 60 + 30) return "PRE";
+  if (totalMinutes < 16 * 60) return "REGULAR";
+  if (totalMinutes < 20 * 60) return "POST";
+  return "POSTPOST";
+}
+
+export function isQuoteMissingActiveSessionPrice(quote: Quote): boolean {
+  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice == null) {
+    return true;
+  }
+  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice == null) {
+    return true;
+  }
+  return false;
+}
+
+export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, now = Date.now()): boolean {
+  if (!quote) return false;
+  if (isQuoteMissingActiveSessionPrice(quote)) return true;
+
+  const exchange = normalizeExchange(quote.listingExchangeName || quote.exchangeName);
+  if (!exchange || !Number.isFinite(quote.lastUpdated)) return false;
+
+  const quoteDate = exchangeLocalDate(exchange, quote.lastUpdated);
+  const currentDate = exchangeLocalDate(exchange, now);
+  if (!quoteDate || !currentDate || quoteDate === currentDate) return false;
+
+  if (quote.marketState === "REGULAR") return true;
+
+  if (isUsExtendedHoursExchange(exchange)) {
+    const session = usSessionState(now);
+    return session === "PRE" || session === "REGULAR" || session === "POST";
+  }
+
+  return false;
+}
+
+export function hasFreshQuoteForCurrentSession(
+  quotes: Iterable<Quote | null | undefined>,
+  now = Date.now(),
+): boolean {
+  for (const quote of quotes) {
+    if (quote && !isQuoteStaleForCurrentSession(quote, now)) {
+      return true;
+    }
+  }
+  return false;
+}