gloomberb 0.13.1 → 0.13.3

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();
   }

package/src/plugins/builtin/chat/controller/session-runtime.ts

@@ -1,4 +1,5 @@
 import { apiClient } from "../../../../api-client";
+import { ApiRequestError } from "../../../../api-client/errors";
 import {
   DEFAULT_CHAT_CHANNEL_ID,
   type ChannelRuntimeState,
@@ -93,7 +94,8 @@ interface RefreshChatControllerSessionOptions {
   ensureRealtimeSubscriptions: () => void;
   persistChannelState: (channelId: string) => void;
   persistSession: (sessionToken: string | null, user: ChatSessionUser | null) => void;
-  refreshChatState: () => Promise<void>;
+  refreshChatState: (isCurrent?: () => boolean) => Promise<void>;
+  scheduleSessionRetry: () => void;
   session: ChatControllerSessionState;
   stopRealtimeSubscriptions: () => void;
   stopSafetyRefresh: () => void;
@@ -110,6 +112,7 @@ export async function refreshChatControllerSession({
   persistChannelState,
   persistSession,
   refreshChatState,
+  scheduleSessionRetry,
   session,
   stopRealtimeSubscriptions,
   stopSafetyRefresh,
@@ -119,20 +122,85 @@ export async function refreshChatControllerSession({
   session.sessionToken = apiClient.getSessionToken();
   const apiSession = await apiClient.getSession();
   if (!apiSession) {
-    const persistedToken = apiClient.getSessionToken() || session.sessionToken;
-    // A 200 with no user is what /auth/get-session returns when no cookie
-    // reached the server. Desktop's backend process used to treat that as a
-    // real sign-out and persist a wiped token, so the next launch was logged
-    // out. Keep a captured native session; hard account-missing responses
-    // already clear the token inside getSession().
+    const persistedToken = apiClient.getSessionToken();
+    // A 200 with no user used to mean the desktop backend had not received the
+    // restored cookie yet, so do not discard a captured native session on that
+    // response alone. Probe another authenticated endpoint: success validates
+    // the token, a 401 proves it expired, and a transient failure keeps offline
+    // startup from signing the user out.
     if (persistedToken) {
       session.sessionToken = persistedToken;
       session.user = session.user ?? normalizeSessionUser(apiClient.getCurrentUser());
+      // getSession() clears the API client's cached user when the endpoint
+      // answers null. Keep both session views aligned while the protected
+      // request validates the preserved native credential.
+      apiClient.restoreCachedUser(session.user);
       session.sessionChecked = true;
       persistSession(session.sessionToken, session.user);
       emit();
+
+      const credentialIsCurrent = () =>
+        apiClient.getSessionToken() === persistedToken && session.sessionToken === persistedToken;
+      const handleValidationError = (error: unknown) => {
+        if (!credentialIsCurrent()) return;
+        if (error instanceof ApiRequestError && error.status === 401) {
+          apiClient.setSessionToken(null);
+          session.sessionToken = null;
+          applySignedOut();
+          return;
+        }
+        if (error instanceof ApiRequestError && error.status === 403 && session.user) {
+          session.user = { ...session.user, emailVerified: false };
+          apiClient.restoreCachedUser(session.user);
+          persistSession(session.sessionToken, session.user);
+          emit();
+          syncVerificationPolling();
+          stopSafetyRefresh();
+          stopRealtimeSubscriptions();
+          return;
+        }
+        scheduleSessionRetry();
+      };
+
+      if (!session.user?.emailVerified) {
+        try {
+          const profile = await apiClient.getAccountProfile();
+          if (!credentialIsCurrent()) return;
+          const persistedProfile = {
+            ...profile,
+            updatedAt: profile.updatedAt ?? undefined,
+          };
+          session.user = normalizeSessionUser(persistedProfile);
+          apiClient.restoreCachedUser(persistedProfile);
+          persistSession(session.sessionToken, session.user);
+          emit();
+        } catch (error) {
+          handleValidationError(error);
+          return;
+        }
+
+        if (!session.user?.emailVerified) {
+          syncVerificationPolling();
+          stopSafetyRefresh();
+          stopRealtimeSubscriptions();
+          return;
+        }
+      }
+
+      try {
+        await refreshChatState(credentialIsCurrent);
+      } catch (error) {
+        handleValidationError(error);
+        return;
+      }
+      if (!credentialIsCurrent()) return;
+
+      stopVerificationPolling();
+      ensureRealtimeSubscriptions();
+      ensureOpenChannelConnections();
       return;
     }
+    session.sessionToken = null;
     applySignedOut();
     return;
   }
@@ -152,7 +220,7 @@ export async function refreshChatControllerSession({
   if (nextUser?.emailVerified) {
     stopVerificationPolling();
     ensureRealtimeSubscriptions();
-    await refreshChatState().catch(() => {});
+    await refreshChatState().catch(() => scheduleSessionRetry());
     ensureOpenChannelConnections();
     return;
   }

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

@@ -21,6 +21,7 @@ export const TRANSCRIPT_CACHE_POLICY = {
 };
 export const DRAFT_SYNC_DEBOUNCE_MS = 250;
 export const VERIFICATION_POLL_MS = 5_000;
+export const SESSION_RETRY_MS = 30_000;
 export const SAFETY_REFRESH_MS = 30_000;
 export const PENDING_RECONCILE_WINDOW_MS = 2 * 60_000;