gloomberb 0.13.1 → 0.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/index.tsx",

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

@@ -264,6 +264,40 @@ describe("apiClient auth cookies", () => {
     ]);
   });
 
+  test("ignores a stale response cookie after the session credential changes", async () => {
+    let releaseResponse: (() => void) | null = null;
+    let markRequestStarted: (() => void) | null = null;
+    const requestStarted = new Promise<void>((resolve) => {
+      markRequestStarted = resolve;
+    });
+
+    apiClient.setSessionToken("old-session.value");
+    setCloudApiFetchTransport(async () => {
+      markRequestStarted?.();
+      await new Promise<void>((resolve) => {
+        releaseResponse = resolve;
+      });
+      return createResponse({
+        channels: [],
+        onlineCount: 0,
+        channelStates: [],
+        notifications: [],
+      }, {
+        cookies: [
+          "__Secure-gloomberb.session_token=old-session.value; Path=/; HttpOnly; Secure; SameSite=None",
+        ],
+      });
+    });
+
+    const staleRequest = apiClient.getChatState();
+    await requestStarted;
+    apiClient.setSessionToken("new-session.value");
+    releaseResponse?.();
+    await staleRequest;
+
+    expect(apiClient.getSessionToken()).toBe("new-session.value");
+  });
+
   test("uses an installed cloud API fetch transport for auth cookie capture", async () => {
     const seenCookies: Array<string | null> = [];
     globalThis.fetch = mockFetch(async () => {

package/src/api-client/request.ts

@@ -141,6 +141,7 @@ export class CloudApiRequestTransport {
       headers.set("Content-Type", "application/json");
     }
     this.setSessionCookieHeader(headers);
+    const sessionTokenAtRequestStart = this.sessionToken;
     headers.set("Origin", this.baseUrl);
 
     const operation = `${options?.method ?? "GET"} ${path.split("?")[0]}`;
@@ -151,7 +152,9 @@ export class CloudApiRequestTransport {
         credentials: "include",
       });
       throwIfRequestAborted(options?.signal);
-      this.extractSessionCookie(res);
+      if (this.sessionToken === sessionTokenAtRequestStart) {
+        this.extractSessionCookie(res);
+      }
       const text = await res.text();
       throwIfRequestAborted(options?.signal);
 

package/src/cli/pane-functions/cloud-session.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test";
+import { apiClient } from "../../api-client";
+import type { MarketContext } from "../types";
+import {
+  resolvePersistedCloudSessionToken,
+  withPersistedCloudSession,
+} from "./cloud-session";
+
+function contextWithSession(
+  key: string,
+  sessionToken: string,
+): Pick<MarketContext, "persistence"> {
+  return {
+    persistence: {
+      pluginState: {
+        get: (_pluginId: string, candidate: string) => candidate === key
+          ? { value: { sessionToken }, schemaVersion: 1, updatedAt: 1 }
+          : null,
+      },
+    },
+  } as Pick<MarketContext, "persistence">;
+}
+
+describe("pane function Cloud session", () => {
+  test("restores the current and legacy persisted session keys", () => {
+    expect(resolvePersistedCloudSessionToken(
+      contextWithSession("resume:session", "current-session"),
+    )).toBe("current-session");
+    expect(resolvePersistedCloudSessionToken(
+      contextWithSession("session", "legacy-session"),
+    )).toBe("legacy-session");
+  });
+
+  test("scopes the persisted session to one report load", async () => {
+    const initial = apiClient.getSessionToken();
+    apiClient.setSessionToken("previous-session");
+    try {
+      let activeSession: string | null = null;
+      const result = await withPersistedCloudSession(
+        contextWithSession("resume:session", "report-session"),
+        async () => {
+          activeSession = apiClient.getSessionToken();
+          return 42;
+        },
+      );
+
+      expect(result).toBe(42);
+      expect(activeSession).toBe("report-session");
+      expect(apiClient.getSessionToken()).toBe("previous-session");
+    } finally {
+      apiClient.setSessionToken(initial);
+    }
+  });
+});

package/src/cli/pane-functions/cloud-session.ts

@@ -0,0 +1,38 @@
+import { apiClient } from "../../api-client";
+import type { MarketContext } from "../types";
+
+const CLOUD_PLUGIN_ID = "gloomberb-cloud";
+const CLOUD_SESSION_KEYS = ["resume:session", "session"] as const;
+
+interface PersistedCloudSession {
+  sessionToken?: unknown;
+}
+
+export function resolvePersistedCloudSessionToken(
+  context: Pick<MarketContext, "persistence">,
+): string | null {
+  for (const key of CLOUD_SESSION_KEYS) {
+    const value = context.persistence.pluginState.get<PersistedCloudSession>(
+      CLOUD_PLUGIN_ID,
+      key,
+      1,
+    )?.value;
+    if (typeof value?.sessionToken === "string" && value.sessionToken.length > 0) {
+      return value.sessionToken;
+    }
+  }
+  return null;
+}
+
+export async function withPersistedCloudSession<T>(
+  context: Pick<MarketContext, "persistence">,
+  run: () => Promise<T>,
+): Promise<T> {
+  const previousSessionToken = apiClient.getSessionToken();
+  apiClient.setSessionToken(resolvePersistedCloudSessionToken(context));
+  try {
+    return await run();
+  } finally {
+    apiClient.setSessionToken(previousSessionToken);
+  }
+}

package/src/cli/pane-functions/index.ts

@@ -28,6 +28,7 @@ import {
   isDataPaneForDomFallback,
   normalizeCapabilityOptions,
 } from "./capabilities";
+import { withPersistedCloudSession } from "./cloud-session";
 
 async function withPaneRuntime<T>(
   ctx: CliCommandContext,
@@ -63,7 +64,10 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
           + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
         );
       }
-      const report = await buildFunctionReport(resolved, context, parsed.arg);
+      const report = await withPersistedCloudSession(
+        context,
+        () => buildFunctionReport(resolved, context, parsed.arg),
+      );
       if (parsed.requireBotSafe && (report.data.empty || !report.data.complete)) {
         const unavailable = report.data.unavailableSymbols.length > 0
           ? ` Missing data for ${report.data.unavailableSymbols.join(", ")}.`

package/src/cli/pane-functions/screenshot.ts

@@ -19,6 +19,7 @@ import { optionPaneState } from "./options";
 import type { ResolvedPaneFunction } from "./resolver";
 import type { MarketContext } from "../types";
 import { capabilityPluginState } from "./capabilities";
+import { resolvePersistedCloudSessionToken } from "./cloud-session";
 import type { RemoteUiNodeSnapshot } from "../../remote/types";
 import {
   graphRowsForFinancials,
@@ -76,8 +77,6 @@ const DESKTOP_CELL_HEIGHT_PX = 18;
 const OPTIONS_PANE_ID = "options";
 const MARKET_VALUATION_PANE_ID = "market-valuation";
 const ECON_STATISTICS_PANE_ID = "econ-statistics";
-const CLOUD_PLUGIN_ID = "gloomberb-cloud";
-const CLOUD_SESSION_KEYS = ["resume:session", "session"] as const;
 const CREDENTIAL_FIELD_NAMES = new Set([
   "accesstoken",
   "accessurl",
@@ -96,10 +95,6 @@ const CREDENTIAL_FIELD_NAMES = new Set([
   "token",
 ]);
 
-interface PersistedShotCloudSession {
-  sessionToken?: unknown;
-}
-
 /**
  * The proxy receives the desktop session out of band. Keeping this separate
  * from DesktopPaneShotPayload prevents the token from entering the page,
@@ -138,21 +133,9 @@ export function stripDesktopShotCredentials<T>(value: T): T {
 export function resolveDesktopShotApiProxy(
   context: Pick<MarketContext, "persistence">,
 ): DesktopPaneShotApiProxy {
-  let sessionToken: string | null = null;
-  for (const key of CLOUD_SESSION_KEYS) {
-    const value = context.persistence.pluginState.get<PersistedShotCloudSession>(
-      CLOUD_PLUGIN_ID,
-      key,
-      1,
-    )?.value;
-    if (typeof value?.sessionToken === "string" && value.sessionToken.length > 0) {
-      sessionToken = value.sessionToken;
-      break;
-    }
-  }
   return {
     baseUrl: getCloudApiBaseUrl(),
-    sessionToken,
+    sessionToken: resolvePersistedCloudSessionToken(context),
   };
 }
 

package/src/components/command-bar/assist/runtime.ts

@@ -42,17 +42,21 @@ export function useCommandBarAssist({
   askAssist: () => void;
   resetAssist: () => boolean;
 } {
-  const [assistState, setAssistState] = useState<AssistRequestState>({ status: "idle" });
+  const [assistState, setRenderedAssistState] = useState<AssistRequestState>({ status: "idle" });
   const assistStateRef = useRef(assistState);
-  assistStateRef.current = assistState;
+  /**
+   * Event handlers can run again before React commits the state they just
+   * queued. Keep their read model current synchronously so repeated Enter
+   * claims one request instead of aborting it and starting another.
+   */
+  const updateAssistState = useCallback((next: AssistRequestState) => {
+    assistStateRef.current = next;
+    setRenderedAssistState(next);
+  }, []);
   const abortRef = useRef<AbortController | null>(null);
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const answersRef = useRef(new Map<string, AssistCommandCandidate[]>());
-  /**
-   * The query the runtime has already acted on, updated the moment a request
-   * starts. Rendered state lags a tick behind, and reading it instead would let
-   * a re-render slip a second debounce past an ask that is already in flight.
-   */
+  /** Query the runtime has already acted on, updated when a request starts. */
   const handledQueryRef = useRef<string | null>(null);
   /** Query the user dismissed with Esc; the section stays gone until it changes. */
   const dismissedQueryRef = useRef<string | null>(null);
@@ -65,12 +69,13 @@ export function useCommandBarAssist({
   getInventoryRef.current = getInventory;
 
   const cancelPending = useCallback(() => {
-    if (debounceRef.current) {
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
-    }
-    abortRef.current?.abort();
+    const debounce = debounceRef.current;
+    debounceRef.current = null;
+    if (debounce !== null) clearTimeout(debounce);
+
+    const controller = abortRef.current;
     abortRef.current = null;
+    controller?.abort();
   }, []);
 
   const resetAssist = useCallback((): boolean => {
@@ -79,9 +84,9 @@ export function useCommandBarAssist({
     if (active.status === "idle" || active.source === "auto") return false;
     cancelPending();
     dismissedQueryRef.current = active.query;
-    setAssistState({ status: "idle" });
+    updateAssistState({ status: "idle" });
     return true;
-  }, [cancelPending]);
+  }, [cancelPending, updateAssistState]);
 
   const runAssist = useCallback((query: string, source: AssistRequestSource) => {
     const trimmed = query.trim();
@@ -96,35 +101,35 @@ export function useCommandBarAssist({
 
     const cached = answersRef.current.get(trimmed);
     if (cached) {
-      setAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates: cached });
+      updateAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates: cached });
       return;
     }
 
     const controller = new AbortController();
     abortRef.current = controller;
-    setAssistState({ status: "loading", query: trimmed, source: resolveSource() });
+    updateAssistState({ status: "loading", query: trimmed, source: resolveSource() });
 
     void (async () => {
       try {
         const response = await apiClient.assistCommand(trimmed, getInventoryRef.current(), {
           signal: controller.signal,
         });
-        if (controller.signal.aborted) return;
+        if (controller.signal.aborted || abortRef.current !== controller) return;
         const candidates = response?.candidates ?? [];
         answersRef.current.set(trimmed, candidates);
-        setAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates });
+        updateAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates });
       } catch (error) {
-        if (controller.signal.aborted) return;
+        if (controller.signal.aborted || abortRef.current !== controller) return;
         const kind = classifyAssistError(error);
         if (kind === "rate-limited") {
           rateLimitedUntilRef.current = Date.now() + ASSIST_RATE_LIMIT_BACKOFF_MS;
         }
-        setAssistState({ status: "error", query: trimmed, source: resolveSource(), kind });
+        updateAssistState({ status: "error", query: trimmed, source: resolveSource(), kind });
       } finally {
         if (abortRef.current === controller) abortRef.current = null;
       }
     })();
-  }, [cancelPending]);
+  }, [cancelPending, updateAssistState]);
 
   const askAssist = useCallback(() => {
     const trimmed = rootQueryRef.current.trim();
@@ -134,17 +139,17 @@ export function useCommandBarAssist({
     // The background ask already on the wire asks this exact question; asking
     // again would only abort it and start the wait over.
     if (active.status === "loading" && active.query === trimmed) {
-      setAssistState({ ...active, source: "explicit" });
+      updateAssistState({ ...active, source: "explicit" });
       return;
     }
     runAssist(trimmed, "explicit");
-  }, [runAssist]);
+  }, [runAssist, updateAssistState]);
 
   useEffect(() => {
     const trimmed = rootQuery.trim();
     const active = assistStateRef.current;
     if (active.status !== "idle" && active.query !== trimmed) {
-      setAssistState({ status: "idle" });
+      updateAssistState({ status: "idle" });
     }
     if (handledQueryRef.current !== null && handledQueryRef.current !== trimmed) {
       // Whatever is in flight describes text the user has already moved past.
@@ -158,21 +163,24 @@ export function useCommandBarAssist({
     const cached = answersRef.current.get(trimmed);
     if (cached) {
       handledQueryRef.current = trimmed;
-      setAssistState({ status: "answered", query: trimmed, source: "auto", candidates: cached });
+      updateAssistState({ status: "answered", query: trimmed, source: "auto", candidates: cached });
       return;
     }
     if (Date.now() < rateLimitedUntilRef.current) return;
 
-    debounceRef.current = setTimeout(() => {
+    const debounce = setTimeout(() => {
+      // A cleared timer can already be queued. Only the timer still owned by
+      // this effect may start a request.
+      if (debounceRef.current !== debounce) return;
       debounceRef.current = null;
       runAssist(trimmed, "auto");
     }, ASSIST_DEBOUNCE_MS);
+    debounceRef.current = debounce;
     return () => {
-      if (!debounceRef.current) return;
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
+      clearTimeout(debounce);
+      if (debounceRef.current === debounce) debounceRef.current = null;
     };
-  }, [autoAsk, cancelPending, rootQuery, runAssist]);
+  }, [autoAsk, cancelPending, rootQuery, runAssist, updateAssistState]);
 
   useEffect(() => cancelPending, [cancelPending]);
 

package/src/components/command-bar/surface/assist.test.tsx

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { act } from "react";
 import { apiClient, setCloudApiFetchTransport } from "../../../api-client";
 import { testRender } from "../../../renderers/opentui/test-utils";
 import type { PluginRegistry } from "../../../plugins/registry";
@@ -255,6 +256,48 @@ describe("CommandBar AI assist", () => {
     expect(requests).toHaveLength(1);
   });
 
+  test("does not restart an ask when Enter repeats before loading renders", async () => {
+    signInVerified();
+    let releaseResponse = () => {};
+    const held = new Promise<void>((resolve) => { releaseResponse = resolve; });
+    const requests = mockAssistTransport(async () => {
+      await held;
+      return jsonResponse({
+        candidates: [{ input: "CHAT #general", title: "Open the general channel", prefix: "CHAT", confidence: 0.9 }],
+      });
+    });
+
+    testSetup = await testRender(
+      <CommandBarHarness query="new chat pane" />,
+      { width: 120, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Thinking…");
+
+    await act(async () => {
+      for (let press = 0; press < 2; press += 1) {
+        testSetup!.renderer.keyInput.emit("keypress", {
+          ctrl: false,
+          meta: false,
+          option: false,
+          shift: false,
+          eventType: "press",
+          name: "return",
+          sequence: "\r",
+          repeated: press > 0,
+          stopPropagation: () => {},
+          preventDefault: () => {},
+        } as any);
+      }
+      await testSetup!.renderOnce();
+    });
+
+    expect(requests).toHaveLength(1);
+    releaseResponse();
+    await waitForFrameToContain("#general · Open the general channel", ASSIST_WAIT_ATTEMPTS);
+  });
+
   test("drops the section when a background ask fails", async () => {
     signInVerified();
     const requests = mockAssistTransport(() => jsonResponse({ error: "assist-unavailable" }, 503));

package/src/news/types.ts

@@ -38,6 +38,7 @@ export interface NewsArticle {
   scores: NewsScores;
   isBreaking: boolean;
   isDeveloping: boolean;
+  sourceCount?: number;
   items?: NewsStoryItem[];
 
   // Compatibility aliases for RSS/Yahoo panes and existing table columns.

package/src/plugins/builtin/chat/controller/channels.ts

@@ -104,12 +104,13 @@ export class ChatControllerChannels {
     return request;
   }
 
-  async refreshChatState(): Promise<void> {
+  async refreshChatState(isCurrent: () => boolean = () => true): Promise<void> {
     if (!this.options.canLoadPrivateState()) {
       await this.refreshPresence();
       return;
     }
     const state = await apiClient.getChatState();
+    if (!isCurrent()) return;
     this.channels = normalizeChannels(state.channels);
     this.onlineCount = state.onlineCount;
     for (const entry of state.channelStates) {

package/src/plugins/builtin/chat/controller/index.ts

@@ -197,9 +197,15 @@ export class ChatController {
   /** Single-flight: every open chat pane calls this on mount. */
   async refreshSession(): Promise<void> {
     if (this.sessionRefreshPromise) return this.sessionRefreshPromise;
-    const request = this.runSessionRefresh().finally(() => {
-      this.sessionRefreshPromise = null;
-    });
+    this.realtime.stopSessionRetry();
+    const request = this.runSessionRefresh()
+      .catch((error) => {
+        this.realtime.scheduleSessionRetry();
+        throw error;
+      })
+      .finally(() => {
+        this.sessionRefreshPromise = null;
+      });
     this.sessionRefreshPromise = request;
     return request;
   }
@@ -215,7 +221,8 @@ export class ChatController {
       ensureRealtimeSubscriptions: () => this.realtime.ensureRealtimeSubscriptions(),
       persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
       persistSession: (sessionToken, user) => this.storage.persistSession(sessionToken, user),
-      refreshChatState: () => this.refreshChatState(),
+      refreshChatState: (isCurrent) => this.channelCatalog.refreshChatState(isCurrent),
+      scheduleSessionRetry: () => this.realtime.scheduleSessionRetry(),
       session: this.session,
       stopRealtimeSubscriptions: () => {
         this.realtime.stopRealtimeSubscriptions();
@@ -337,11 +344,12 @@ export class ChatController {
     this.appActive = appActive;
     if (!appActive) {
       this.realtime.stopVerificationPolling();
+      this.realtime.stopSessionRetry();
       return;
     }
     this.markFocusedViewsViewed();
     this.realtime.syncVerificationPolling();
-    void this.refreshChatState()
+    void this.refreshSession()
       .then(() => this.markFocusedViewsViewed())
       .catch(() => {});
   }

package/src/plugins/builtin/chat/controller/realtime.ts

@@ -1,6 +1,7 @@
 import { apiClient, type ChatNotification } from "../../../../api-client";
 import {
   SAFETY_REFRESH_MS,
+  SESSION_RETRY_MS,
   VERIFICATION_POLL_MS,
 } from "./state";
 
@@ -18,6 +19,7 @@ interface ChatControllerRealtimeOptions {
 
 export class ChatControllerRealtime {
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
+  private sessionRetryTimer: ReturnType<typeof setTimeout> | null = null;
   private safetyRefreshTimer: ReturnType<typeof setInterval> | null = null;
   private chatNotificationUnsubscribe: (() => void) | null = null;
   private chatPresenceUnsubscribe: (() => void) | null = null;
@@ -36,6 +38,27 @@ export class ChatControllerRealtime {
     }, VERIFICATION_POLL_MS);
   }
 
+  scheduleSessionRetry(): void {
+    if (
+      this.sessionRetryTimer
+      || !this.options.getAppActive()
+      || !this.options.hasSession()
+    ) {
+      return;
+    }
+    this.sessionRetryTimer = setTimeout(() => {
+      this.sessionRetryTimer = null;
+      void this.options.refreshSession().catch(() => {});
+    }, SESSION_RETRY_MS);
+    this.sessionRetryTimer.unref?.();
+  }
+
+  stopSessionRetry(): void {
+    if (!this.sessionRetryTimer) return;
+    clearTimeout(this.sessionRetryTimer);
+    this.sessionRetryTimer = null;
+  }
+
   ensureRealtimeSubscriptions(): void {
     if (!this.chatNotificationUnsubscribe) {
       this.chatNotificationUnsubscribe = apiClient.subscribeChatNotifications((notification) => {
@@ -85,6 +108,7 @@ export class ChatControllerRealtime {
 
   stopAll(): void {
     this.stopVerificationPolling();
+    this.stopSessionRetry();
     this.stopSafetyRefresh();
     this.stopRealtimeSubscriptions();
   }