@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/news/aggregator.ts

@@ -1,7 +1,8 @@
+import type { CompanyFrom } from "../types/company-from";
 import { logFailure } from "../utils/log-failure";
 import type { NewsCapability } from "../capabilities";
 import type { ConnectionHealthRegistry } from "../core/connection-health";
-import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
+import type { NewsAccess, NewsArticle, NewsQuery, NewsQueryState } from "./types";
 import { isAppVisible, subscribeAppVisibility } from "../state/app/activity";
 import {
   DEFAULT_GLOBAL_QUERY,
@@ -28,6 +29,18 @@ export interface NewsServiceOptions {
   connectionHealth?: ConnectionHealthRegistry;
   /** Defaults to the app's visibility; injectable for tests. */
   visibility?: { isVisible(): boolean; subscribe(listener: () => void): () => void };
+  /**
+   * The session the sources read news with. Its key changes when what the
+   * service answers changes: a session restored at launch, a sign-in or
+   * sign-out, an upgrade. Every open query is then read again and its stories
+   * replaced, so a feed read without the session is not left on screen.
+   */
+  session?: NewsSessionSignal;
+}
+
+export interface NewsSessionSignal {
+  key(): string;
+  subscribe(listener: () => void): () => void;
 }
 
 export type NewsQueryListener = (state: NewsQueryState) => void;
@@ -50,17 +63,31 @@ interface SourceFetchResult {
   failedSourceIds: string[];
   errors: string[];
   nextCursor: string | null;
+  access: NewsAccess | null;
+  companyFrom?: CompanyFrom | null;
 }
 
 interface NewsQueryEntry {
   query: NewsQuery;
   state: NewsQueryState;
   inFlight: Promise<NewsQueryState> | null;
+  /** The session generation the read in flight went out under. */
+  inFlightGeneration: number;
   loadMoreInFlight: Promise<void> | null;
+  loadMoreGeneration: number;
+  /** The session generation the stories on screen were read under. */
+  generation: number;
   refs: number;
   lastAccessedAt: number;
 }
 
+/** Held back beats live: one source the service held back is enough to say the list is not the live wire. */
+function combineNewsAccess(values: ReadonlyArray<NewsAccess | null | undefined>): NewsAccess | null {
+  if (values.includes("delayed")) return "delayed";
+  if (values.includes("realtime")) return "realtime";
+  return null;
+}
+
 function newsCapabilityPriority(source: NewsCapability): number {
   return source.priority ?? 1000;
 }
@@ -85,6 +112,12 @@ export class NewsService {
   private readonly visibility: NonNullable<NewsServiceOptions["visibility"]>;
   private lastPollAt = 0;
   private unsubscribeVisibility: (() => void) | null = null;
+  private readonly session?: NewsSessionSignal;
+  private sessionKey: string | null = null;
+  /** Bumped when the session changes; a read from an older generation is dropped. */
+  private sessionGeneration = 0;
+  private sessionRefetchQueued = false;
+  private unsubscribeSession: (() => void) | null = null;
 
   constructor(options: NewsServiceOptions = {}) {
     const pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -94,6 +127,7 @@ export class NewsService {
     this.now = options.now ?? Date.now;
     this.connectionHealth = options.connectionHealth;
     this.visibility = options.visibility ?? { isVisible: isAppVisible, subscribe: subscribeAppVisibility };
+    this.session = options.session;
   }
 
   register(source: NewsCapability): () => void {
@@ -125,6 +159,10 @@ export class NewsService {
       this.clearPollTimer();
       this.scheduleNextPoll();
     });
+    if (this.session) {
+      this.sessionKey = this.session.key();
+      this.unsubscribeSession = this.session.subscribe(() => this.handleSessionChange());
+    }
     this.scheduleNextPoll();
   }
 
@@ -132,9 +170,46 @@ export class NewsService {
     this.polling = false;
     this.unsubscribeVisibility?.();
     this.unsubscribeVisibility = null;
+    this.unsubscribeSession?.();
+    this.unsubscribeSession = null;
     this.clearPollTimer();
   }
 
+  /**
+   * A new session answers with other news: the live wire once a Pro session
+   * is in place, the held-back one after signing out. Reads still out under
+   * the old session are dropped, open queries are read again and replace
+   * their stories rather than merge into them, and closed ones are forgotten.
+   * A token and its user arrive as separate changes, so the reads wait for
+   * the end of the tick and go out once.
+   */
+  private handleSessionChange(): void {
+    if (!this.session) return;
+    const key = this.session.key();
+    if (key === this.sessionKey) return;
+    this.sessionKey = key;
+    this.sessionGeneration++;
+    if (this.sessionRefetchQueued) return;
+    this.sessionRefetchQueued = true;
+    queueMicrotask(() => {
+      this.sessionRefetchQueued = false;
+      if (!this.polling) return;
+      let dropped = false;
+      for (const [queryKey, entry] of this.queries) {
+        if (entry.refs > 0) continue;
+        this.queries.delete(queryKey);
+        dropped = true;
+      }
+      if (dropped) {
+        this.rebuildArticlePool();
+        this.notify();
+      }
+      for (const entry of this.queries.values()) {
+        void this.refreshQuery(entry.query, true);
+      }
+    });
+  }
+
   private pollInFlight = false;
 
   private clearPollTimer(): void {
@@ -226,6 +301,7 @@ export class NewsService {
       return;
     }
 
+    const generation = this.sessionGeneration;
     const request = (async () => {
       entry.state = { ...entry.state, loadingMore: true };
       this.notify();
@@ -234,6 +310,12 @@ export class NewsService {
           ...normalized,
           cursor: entry.state.nextCursor ?? undefined,
         });
+        // An older page from another session must not join the list the new session read.
+        if (generation !== this.sessionGeneration || entry.generation !== generation) {
+          entry.state = { ...entry.state, loadingMore: false };
+          this.notify();
+          return;
+        }
         entry.state = {
           ...entry.state,
           loadingMore: false,
@@ -253,6 +335,7 @@ export class NewsService {
       }
     })();
     entry.loadMoreInFlight = request;
+    entry.loadMoreGeneration = generation;
     await request;
   }
 
@@ -318,7 +401,9 @@ export class NewsService {
     showLoading: boolean,
   ): Promise<NewsQueryState> {
     const entry = this.getOrCreateQueryEntry(query);
-    if (entry.inFlight) return entry.inFlight;
+    const generation = this.sessionGeneration;
+    // A read that went out under an older session answers for that session: a new one goes out beside it.
+    if (entry.inFlight && entry.inFlightGeneration === generation) return entry.inFlight;
 
     const current = entry.state;
     if (showLoading) {
@@ -333,14 +418,17 @@ export class NewsService {
     const promise = (async () => {
       try {
         const result = await this.fetchFromSources(query);
+        if (generation !== this.sessionGeneration) return this.currentRead(entry);
         if (result.sourceIds.length === 0 && result.failedSourceIds.length > 0) {
           throw new Error("News sources unavailable.");
         }
-        if (entry.loadMoreInFlight) return entry.state;
+        if (entry.loadMoreInFlight && entry.loadMoreGeneration === generation) return entry.state;
         const incoming = filterNewsArticlesForQuery(dedupeNewsArticles(result.articles), query);
+        // Stories read under another session are another feed (held back, or live): the new read replaces them.
+        const sameSession = entry.generation === generation;
         // The stories a coin's fallback found are not the pair's own: once stories are filed under it, they replace them.
-        const existing = incoming.length > 0 && entry.state.articles.length > 0
-          && (incoming[0]!.searchedFor ?? null) !== (entry.state.articles[0]!.searchedFor ?? null)
+        const existing = !sameSession || (incoming.length > 0 && entry.state.articles.length > 0
+          && (incoming[0]!.searchedFor ?? null) !== (entry.state.articles[0]!.searchedFor ?? null))
           ? []
           : entry.state.articles;
         const incomingIds = new Set(incoming.map((article) => article.id));
@@ -363,13 +451,18 @@ export class NewsService {
           sourceIds: result.sourceIds,
           nextCursor: hasOlderPages ? entry.state.nextCursor : result.nextCursor,
           loadingMore: entry.state.loadingMore,
+          // A page that does not say keeps what this session's earlier answer said.
+          access: result.access ?? (sameSession ? entry.state.access ?? null : null),
+          companyFrom: result.companyFrom ?? null,
         };
         entry.state = state;
+        entry.generation = generation;
         entry.lastAccessedAt = this.now();
         this.rebuildArticlePool();
         this.notify();
         return state;
       } catch (error) {
+        if (generation !== this.sessionGeneration) return this.currentRead(entry);
         const state: NewsQueryState = {
           ...current,
           phase: "error",
@@ -380,15 +473,21 @@ export class NewsService {
         this.notify();
         return state;
       } finally {
-        entry.inFlight = null;
+        if (entry.inFlightGeneration === generation) entry.inFlight = null;
         this.pruneInactiveQueries();
       }
     })();
 
     entry.inFlight = promise;
+    entry.inFlightGeneration = generation;
     return promise;
   }
 
+  /** What a dropped read answers its caller: the current session's read when one is out, else the state as it is. */
+  private currentRead(entry: NewsQueryEntry): Promise<NewsQueryState> | NewsQueryState {
+    return entry.inFlight && entry.inFlightGeneration === this.sessionGeneration ? entry.inFlight : entry.state;
+  }
+
   private getOrCreateQueryEntry(query: NewsQuery): NewsQueryEntry {
     const key = buildNewsQueryKey(query);
     const now = this.now();
@@ -402,7 +501,10 @@ export class NewsService {
       query,
       state: createIdleNewsQueryState(),
       inFlight: null,
+      inFlightGeneration: this.sessionGeneration,
       loadMoreInFlight: null,
+      loadMoreGeneration: this.sessionGeneration,
+      generation: this.sessionGeneration,
       refs: 0,
       lastAccessedAt: now,
     };
@@ -451,7 +553,7 @@ export class NewsService {
   private async readSourcePage(
     source: NewsCapability,
     query: NewsQuery,
-  ): Promise<{ articles: NewsArticle[]; nextCursor: string | null; error?: string | null }> {
+  ): Promise<{ articles: NewsArticle[]; nextCursor: string | null; error?: string | null; access?: NewsAccess | null; companyFrom?: CompanyFrom | null }> {
     if (source.provider.fetchNewsPage) {
       const page = await this.trackSourceRequest(
         source,
@@ -462,6 +564,8 @@ export class NewsService {
         articles: page.articles.map((article) => markDetailCapableArticle(source, article)),
         nextCursor: page.nextCursor ?? null,
         error: page.error,
+        access: page.access,
+        companyFrom: page.companyFrom ?? null,
       };
     }
     const articles = (await this.trackSourceRequest(
@@ -484,6 +588,8 @@ export class NewsService {
           failedSourceIds,
           errors: page.error ? [page.error] : [],
           nextCursor: page.nextCursor,
+          access: page.access ?? null,
+          companyFrom: page.companyFrom ?? null,
         };
         if (page.articles.length > 0) return result;
         firstEmpty ??= result;
@@ -491,7 +597,7 @@ export class NewsService {
         failedSourceIds.push(newsCapabilitySourceId(source));
       }
     }
-    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds, errors: [], nextCursor: null };
+    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds, errors: [], nextCursor: null, access: null };
   }
 
   private async fetchMergedNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
@@ -505,6 +611,7 @@ export class NewsService {
     const errors: string[] = [];
     const sourceIds: string[] = [];
     const failedSourceIds: string[] = [];
+    const access: Array<NewsAccess | null | undefined> = [];
     let nextCursor: string | null = null;
     settled.forEach((result, index) => {
       if (result.status !== "fulfilled") {
@@ -515,9 +622,10 @@ export class NewsService {
       articles.push(...result.value.page.articles);
       if (result.value.page.error) errors.push(result.value.page.error);
       sourceIds.push(newsCapabilitySourceId(result.value.source));
+      access.push(result.value.page.access);
       nextCursor ??= result.value.page.nextCursor;
     });
-    return { articles, sourceIds, failedSourceIds, errors, nextCursor };
+    return { articles, sourceIds, failedSourceIds, errors, nextCursor, access: combineNewsAccess(access) };
   }
 
   private trackSourceRequest<T>(
@@ -550,6 +658,8 @@ export class NewsService {
         sourceIds: [...new Set([...entry.state.sourceIds, newsCapabilitySourceId(source)])],
         nextCursor: entry.state.nextCursor,
         loadingMore: false,
+        access: entry.state.access ?? null,
+        companyFrom: entry.state.companyFrom ?? null,
       };
       changed = true;
     }

package/src/news/cloud-session.ts

@@ -0,0 +1,21 @@
+import { apiClient } from "../api-client";
+import { hasProAccess } from "../api-client/plan-rules";
+import type { NewsSessionSignal } from "./aggregator";
+
+/**
+ * What decides which news Gloom Cloud answers with: whether requests carry a
+ * session, whose it is, and whether that account has real-time news. Changes
+ * when the session is restored at launch, on sign-in and sign-out, and when
+ * the plan changes.
+ */
+export const cloudNewsSession: NewsSessionSignal = {
+  key() {
+    const user = apiClient.getCurrentUser();
+    return [
+      apiClient.hasSessionCredential() ? "session" : "none",
+      user?.id ?? "",
+      hasProAccess(user) ? "realtime" : "delayed",
+    ].join(":");
+  },
+  subscribe: (listener) => apiClient.subscribeCurrentUser(listener),
+};

package/src/news/hooks.ts

@@ -22,6 +22,7 @@ const IDLE_NEWS_QUERY_STATE: NewsQueryState = {
   sourceIds: [],
   nextCursor: null,
   loadingMore: false,
+  access: null,
 };
 
 export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryState {

package/src/news/news-model.ts

@@ -92,6 +92,7 @@ export function createIdleNewsQueryState(): NewsQueryState {
     sourceIds: [],
     nextCursor: null,
     loadingMore: false,
+    access: null,
   };
 }
 

package/src/news/types.ts

@@ -1,3 +1,5 @@
+import type { CompanyFrom } from "../types/company-from";
+
 type NewsQueryScope = "global" | "ticker";
 export type NewsFeed = "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
 type NewsSentiment = "positive" | "neutral" | "negative";
@@ -81,11 +83,22 @@ export interface NewsQuery {
 
 type NewsQueryPhase = "idle" | "loading" | "ready" | "refreshing" | "error";
 
+/**
+ * Which news a source answered with: the live wire, or the one held back for
+ * an account without real-time news. Read from the answer itself, never from
+ * the plan the app remembers.
+ */
+export type NewsAccess = "realtime" | "delayed";
+
 export interface NewsPage {
   /** Active source failure, including a partial failure with usable articles. */
   error?: string | null;
   articles: NewsArticle[];
   nextCursor?: string | null;
+  /** Which news the source answered with; null or absent when the answer does not say. */
+  access?: NewsAccess | null;
+  /** The company's home line the stories are read from, when not the listing asked (a receipt, a foreign line). */
+  companyFrom?: CompanyFrom | null;
 }
 
 export interface NewsQueryState {
@@ -96,4 +109,8 @@ export interface NewsQueryState {
   sourceIds: string[];
   nextCursor: string | null;
   loadingMore: boolean;
+  /** Which news the stories are, from the last answer; null or absent when it did not say. */
+  access?: NewsAccess | null;
+  /** The company's home line the stories are read from, when not the listing asked. */
+  companyFrom?: CompanyFrom | null;
 }

package/src/plugins/builtin/alerts/alert-engine.ts

@@ -1,5 +1,7 @@
 import { metricDescription, readAlertMetric, validMetricRule } from "./metric-model";
 import type { AlertCondition, AlertRule } from "./types";
+import { alertListing } from "./format";
+import { canonicalExchange } from "../../../utils/exchanges";
 import { logFailure } from "../../../utils/log-failure";
 
 export type { AlertRule };
@@ -33,10 +35,14 @@ export function editAlert(
   targetPrice: number,
 ): AlertRule {
   const nextSymbol = symbol.trim().toUpperCase();
+  const sameListing = nextSymbol === alert.symbol.trim().toUpperCase();
   return {
     id: alert.id,
     symbol: nextSymbol,
-    exchange: nextSymbol === alert.symbol.trim().toUpperCase() ? alert.exchange : undefined,
+    exchange: sameListing ? alert.exchange : undefined,
+    // The listing's currency and venue stay with it; a new symbol learns its own at its first check.
+    ...(sameListing && alert.lastQuoteCurrency ? { lastQuoteCurrency: alert.lastQuoteCurrency } : {}),
+    ...(sameListing && alert.lastQuoteExchange ? { lastQuoteExchange: alert.lastQuoteExchange } : {}),
     condition,
     targetPrice,
     createdAt: alert.createdAt,
@@ -51,6 +57,19 @@ export function rearmAlert(alert: AlertRule): AlertRule {
   return editAlert(alert, alert.symbol, alert.condition, alert.targetPrice);
 }
 
+/**
+ * Whether two level alerts are one rule: the same measure, condition and
+ * target on the same listing, whether it was named with its exchange or read
+ * from the symbol alone. A second add of one names the first and adds nothing.
+ */
+export function sameLevelRule(a: AlertRule, b: AlertRule): boolean {
+  const venue = (alert: AlertRule) => canonicalExchange(alert.exchange ?? "");
+  return a.symbol.toUpperCase() === b.symbol.toUpperCase()
+    && (venue(a) === venue(b) || alertListing(a) === alertListing(b))
+    && a.condition === b.condition && a.targetPrice === b.targetPrice
+    && JSON.stringify(readAlertMetric(a.metric)) === JSON.stringify(readAlertMetric(b.metric));
+}
+
 export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
   if (alert.metric || alert.status !== "active") return false;
 

package/src/plugins/builtin/alerts/alert-log.ts

@@ -0,0 +1,33 @@
+import { metricDescription } from "./metric-model";
+import { eventAlertTarget, type EventAlertRule } from "./events";
+import { alertChangeEntry, appendFiredAlert, readFiredAlerts, type AlertLogAction, type FiredAlert } from "./fired-log";
+import { alertListing } from "./format";
+import { isResearchAlertKind, readResearchRule } from "./research-rules";
+import { readScheduledRule, scheduledEventName } from "./scheduled";
+import type { AlertRule } from "./types";
+
+/**
+ * A rule as the alert log names it: its kind, the rule in words (`EWG:ARCA
+ * below 40`, as a fired price alert reads) and the symbol it follows.
+ */
+export function alertLogRule(rule: AlertRule | EventAlertRule) {
+  if ("symbol" in rule) {
+    return {
+      kind: rule.metric?.kind ?? "price", ruleId: rule.id,
+      rule: rule.metric ? metricDescription(rule) : `${alertListing(rule)} ${rule.condition} ${rule.targetPrice}`,
+      symbol: rule.symbol, ...rule.exchange ? { exchange: rule.exchange } : {},
+    };
+  }
+  const scheduled = readScheduledRule(rule);
+  const symbol = scheduled?.target.kind === "earnings" ? scheduled.target.symbol
+    : isResearchAlertKind(rule.kind) ? readResearchRule(rule.kind, rule.value)?.symbol : undefined;
+  return {
+    kind: rule.kind, ruleId: rule.id, rule: scheduled ? scheduledEventName(scheduled.target) : eventAlertTarget(rule),
+    ...symbol ? { symbol } : {},
+  };
+}
+
+/** The saved log with one change more: what the pane's `usePluginState(FIRED_LOG_KEY)` setter takes. */
+export function withAlertChange(saved: unknown, action: AlertLogAction, rule: AlertRule | EventAlertRule, at = Date.now()): FiredAlert[] {
+  return appendFiredAlert(readFiredAlerts(saved), alertChangeEntry(action, alertLogRule(rule), at));
+}

package/src/plugins/builtin/alerts/calendar-events.ts

@@ -3,7 +3,7 @@
 // release's rows as the calendar's feeds name it from week to week, and the
 // notifications sent before it and once its figures are out. CPI and FOMC are
 // two cases of the same alert, whose dates come from their own calendars.
-import { dateKey, eventCountry, matchesCountry, type CountryFilter } from "../econ/calendar-model";
+import { dateKey, econEventName, eventCountry, matchesCountry, type CountryFilter } from "../econ/calendar-model";
 import { isAllDayEvent, hasNoReleaseTime, type EconEvent, type EconImpact } from "../econ/types";
 import { RENAMED_RELEASES } from "../shared/macro-releases";
 import { MACRO_EVENT_NAMES } from "./research-builder";
@@ -126,7 +126,11 @@ export interface CalendarEventChoice {
 
 const IMPACT_RANK: Record<EconImpact, number> = { high: 0, medium: 1, low: 2 };
 
-type RankedChoice = CalendarEventChoice & { words: string[] };
+type RankedChoice = CalendarEventChoice & {
+  words: string[];
+  /** The words of the name `econ` shows it under, when that is not the feed's (the Fed's rate as its upper bound). */
+  shownWords: string[];
+};
 
 /**
  * The calendar's releases, one per country and name, each with its next row
@@ -150,6 +154,7 @@ function calendarChoices(events: readonly EconEvent[], now: number): RankedChoic
       impact: rows.reduce<EconImpact>((best, event) => IMPACT_RANK[event.impact] < IMPACT_RANK[best] ? event.impact : best, "low"),
       next,
       words: calendarNameWords(named.event),
+      shownWords: calendarNameWords(econEventName(named)),
     };
   });
 }
@@ -246,7 +251,8 @@ function matchCalendarWords(
   now: number,
 ): CalendarEventMatch {
   const choices = calendarChoices(country ? events.filter((event) => matchesCountry(event, country)) : events, now);
-  const exact = choices.filter((choice) => choice.words.join(" ") === words.join(" "));
+  // The name as the feed gives it, or as `econ` shows it: the alert keeps the feed's, which the calendar's rows carry.
+  const exact = choices.filter((choice) => [choice.words, choice.shownWords].some((name) => name.join(" ") === words.join(" ")));
   const naming = (typed: readonly string[], loose: boolean) => typed.length === 0 ? [] : choices.filter((choice) =>
     typed.every((word) => loose ? wordFound(word, choice.words) : choice.words.includes(word)));
   // CPI by the name one feed gives it everywhere but the US (China's Inflation Rate YoY).
@@ -278,7 +284,7 @@ function matchCalendarWords(
   return { kind: "match", choice: strip(ranked[0]!), others: ranked.slice(1).map(strip) };
 }
 
-function strip({ words: _words, ...choice }: RankedChoice): CalendarEventChoice {
+function strip({ words: _words, shownWords: _shown, ...choice }: RankedChoice): CalendarEventChoice {
   return choice;
 }