gloomberb 0.11.0 → 0.11.2

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

@@ -93,6 +93,7 @@ beforeEach(() => {
 afterEach(() => {
   apiClient.dispose();
   apiClient.setSessionToken(null);
+  apiClient.setCookieSessionMode(false);
   apiClient.connectChannel = originalConnectChannel;
   apiClient.getSession = originalGetSession;
   apiClient.getMessages = originalGetMessages;
@@ -147,6 +148,47 @@ describe("ChatController", () => {
     expect(snapshot.messages.map((entry) => entry.id)).toEqual(["m1"]);
   });
 
+  test("uses a browser cookie session without exposing its token", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const sentMessages: string[] = [];
+
+    apiClient.setCookieSessionMode(true);
+    apiClient.restoreCachedUser({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+    apiClient.getSession = async () => apiClient.getCurrentUser();
+    apiClient.connectChannel = () => ({
+      send: async (content) => {
+        sentMessages.push(content);
+        return {
+          id: "m1",
+          channelId: "everyone",
+          content,
+          replyToId: null,
+          createdAt: "2026-08-23T00:00:00.000Z",
+          user: { id: "u1", username: "vince", displayName: "Vince" },
+        };
+      },
+      close: () => {},
+    });
+
+    controller.attachPersistence(persistence);
+    await controller.refreshSession();
+
+    expect(apiClient.getSessionToken()).toBeNull();
+    expect(controller.getSnapshot()).toMatchObject({
+      hasSavedSession: true,
+      user: { id: "u1", username: "vince", emailVerified: true },
+    });
+    expect(controller.send("hello from the browser")).toBe(true);
+    await flushMicrotasks();
+    expect(sentMessages).toEqual(["hello from the browser"]);
+    controller.dispose();
+  });
+
   test("rejects unknown shortcut channels after the server list loads", async () => {
     const controller = new ChatController();
     apiClient.getChannels = async () => SERVER_CHAT_CHANNELS;
@@ -157,6 +199,42 @@ describe("ChatController", () => {
     );
   });
 
+  test("keeps private channels when a public refresh finishes after chat state", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const directChannel: ChatChannel = {
+      id: "dm:u2",
+      name: "u2",
+      kind: "direct",
+      created_at: "2026-03-28T00:00:00.000Z",
+    };
+    let resolvePublicChannels: ((channels: ChatChannel[]) => void) | undefined;
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    apiClient.getChannels = () => new Promise((resolve) => {
+      resolvePublicChannels = resolve;
+    });
+    apiClient.getChatState = async () => ({
+      channels: [...SERVER_CHAT_CHANNELS, directChannel],
+      onlineCount: 0,
+      channelStates: [],
+      notifications: [],
+    });
+    controller.attachPersistence(persistence);
+
+    const publicRefresh = controller.refreshChannels();
+    await controller.refreshChatState();
+    expect(controller.getChannels().map((channel) => channel.id)).toContain(directChannel.id);
+
+    resolvePublicChannels!(SERVER_CHAT_CHANNELS);
+    await publicRefresh;
+
+    expect(controller.getChannels().map((channel) => channel.id)).toContain(directChannel.id);
+  });
+
   test("hydrates a cached verified user into the api client for offline use", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -375,6 +453,55 @@ describe("ChatController", () => {
     }
   });
 
+  test("keeps a persisted native session when get-session returns no user", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+    apiClient.getSession = async () => null;
+
+    await controller.refreshSession();
+
+    expect(apiClient.getSessionToken()).toBe("token-123");
+    expect(persistence.getState<{
+      sessionToken: string;
+      user: { id: string; username: string; emailVerified: boolean };
+    }>("session", { schemaVersion: 1 })).toEqual({
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    });
+    expect(controller.getSnapshot().user).toEqual({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+    controller.dispose();
+  });
+
+  test("signs out when get-session returns no user and no token is stored", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: null,
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+    apiClient.getSession = async () => null;
+
+    await controller.refreshSession();
+
+    expect(apiClient.getSessionToken()).toBeNull();
+    expect(controller.getSnapshot().user).toBeNull();
+    controller.dispose();
+  });
+
   test("keeps the cached session when session refresh fails transiently", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -1021,8 +1148,7 @@ describe("ChatController", () => {
     (controller as any).handleChatNotification(mentionNotification());
 
     expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      subtitle: "#everyone",
+      title: "#everyone",
       body: "@bob mentioned you: hey @vince",
       type: "info",
       desktop: "when-inactive",
@@ -1246,8 +1372,7 @@ describe("ChatController", () => {
       unreadCount: 3,
     });
     expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      subtitle: "#options",
+      title: "#options",
       body: "@bob replied to you: answering you",
       type: "info",
       desktop: "when-inactive",
@@ -1327,10 +1452,11 @@ describe("ChatController", () => {
     expect(notifications).toHaveLength(1);
   });
 
-  test("displays server-issued channel notifications", () => {
+  test("opens a server-issued channel notification at its exact message", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
     const notifications: AppNotificationRequest[] = [];
+    const openedMessages: string[] = [];
     const message: ChatMessage = {
       id: "m1",
       channelId: "options",
@@ -1346,6 +1472,8 @@ describe("ChatController", () => {
     }, { schemaVersion: 1 });
     controller.setNotifier((entry) => {
       notifications.push(entry);
+    }, (channelId, messageId) => {
+      openedMessages.push(`${channelId}:${messageId}`);
     });
     controller.attachPersistence(persistence);
 
@@ -1359,15 +1487,17 @@ describe("ChatController", () => {
     } satisfies ChatNotification);
 
     expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      subtitle: "#options",
-      body: "#options @bob: new option flow",
+      title: "#options",
+      body: "@bob: new option flow",
       type: "info",
       desktop: "when-inactive",
+      action: expect.objectContaining({ label: "Open" }),
     }]);
+    notifications[0]?.action?.onClick();
+    expect(openedMessages).toEqual(["options:m1"]);
   });
 
-  test("uses direct channel labels in server-issued notification subtitles", async () => {
+  test("uses direct channel labels in server-issued notification titles", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
     const notifications: AppNotificationRequest[] = [];
@@ -1418,9 +1548,8 @@ describe("ChatController", () => {
     } satisfies ChatNotification);
 
     expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      subtitle: "@bob",
-      body: "@bob: ping",
+      title: "@bob",
+      body: "ping",
       type: "info",
       desktop: "when-inactive",
     }]);
@@ -1491,8 +1620,7 @@ describe("ChatController", () => {
     } satisfies ChatNotification);
 
     expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      subtitle: "#options",
+      title: "#options",
       body: "@bob replied to you: reply without channel notify",
       type: "info",
       desktop: "when-inactive",

package/src/plugins/builtin/chat/message/desktop.test.tsx

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { createTestRenderer } from "@opentui/core/testing";
+import { act } from "react";
+import { createOpenTuiTestRoot as createRoot } from "../../../../renderers/opentui/test-utils";
+import { getThemeColors, syncTheme } from "../../../../theme/colors";
+import { ThemeProvider } from "../../../../theme/theme-context";
+import { DEFAULT_THEME } from "../../../../theme/themes";
+import type { ChatMessage } from "../../../../api-client";
+import { DesktopChatMessage } from "./desktop";
+
+let testSetup: Awaited<ReturnType<typeof createTestRenderer>> | undefined;
+let root: ReturnType<typeof createRoot> | undefined;
+const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+
+function rgba(hex: string): string {
+  const value = hex.slice(1);
+  return [0, 2, 4].map((offset) => parseInt(value.slice(offset, offset + 2), 16)).concat(255).join(",");
+}
+
+afterEach(async () => {
+  if (root) {
+    await act(async () => {
+      root?.unmount();
+      await Promise.resolve();
+    });
+  }
+  testSetup?.renderer.destroy();
+  root = undefined;
+  testSetup = undefined;
+  syncTheme(DEFAULT_THEME);
+});
+
+describe("DesktopChatMessage", () => {
+  test("updates memoized row colors when the theme changes", async () => {
+    const message: ChatMessage = {
+      id: "theme-message",
+      channelId: "everyone",
+      content: "theme message",
+      replyToId: null,
+      createdAt: "2026-08-25T12:00:00.000Z",
+      user: { id: "user-1", username: "vince", displayName: "Vince" },
+    };
+    const noop = () => {};
+    const messageElement = (
+      <DesktopChatMessage
+        msg={message}
+        index={0}
+        messages={[message]}
+        selectedIdx={0}
+        hoveredIdx={null}
+        canSend={false}
+        catalog={{}}
+        userByUsername={new Map()}
+        openTicker={noop}
+        onUserHover={noop}
+        onUserHoverEnd={noop}
+        beginReplyTo={noop}
+        beginEditMessage={() => false}
+        jumpToMessage={noop}
+        latestEditableMessageId={null}
+        registerMessageElement={noop}
+      />
+    );
+
+    testSetup = await createTestRenderer({ width: 60, height: 4 });
+    root = createRoot(testSetup.renderer);
+    act(() => root?.render(<ThemeProvider themeId={DEFAULT_THEME}>{messageElement}</ThemeProvider>));
+    await act(async () => {
+      await testSetup?.renderOnce();
+      await testSetup?.renderOnce();
+    });
+
+    const nextThemeId = "github-light";
+    act(() => root?.render(<ThemeProvider themeId={nextThemeId}>{messageElement}</ThemeProvider>));
+    await act(async () => {
+      await testSetup?.renderOnce();
+      await testSetup?.renderOnce();
+    });
+
+    const bodySpan = testSetup.captureSpans().lines
+      .flatMap((line) => line.spans)
+      .find((span) => span.text.includes(message.content));
+    const palette = getThemeColors(nextThemeId);
+    expect(bodySpan?.fg.toInts().join(",")).toBe(rgba(palette.selectedText));
+    expect(bodySpan?.bg.toInts().join(",")).toBe(rgba(palette.selected));
+  });
+});

package/src/plugins/builtin/chat/message/desktop.tsx

@@ -1,6 +1,7 @@
 import { memo } from "react";
 import { Box, Span, Text } from "../../../../ui";
 import { hoverBg } from "../../../../theme/colors";
+import { useThemeColors } from "../../../../theme/theme-context";
 import { t } from "../../../../i18n";
 import { useAppLanguage } from "../../../../i18n/react";
 import { MESSAGE_ACTION_WIDTH, normalizeInlinePreview } from "../layout";
@@ -32,6 +33,7 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
   registerMessageElement: (messageId: string, node: unknown | null) => void;
 }) {
   useAppLanguage();
+  const themeColors = useThemeColors();
   const state = getChatMessageRenderState({ msg, index, messages, selectedIdx, hoveredIdx, canSend });
   const canEditMessage = msg.id === latestEditableMessageId;
   const showInlineReplyAction = !state.grouped && canSend;
@@ -58,7 +60,7 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
       data-gloom-role="chat-message"
       data-gloom-chat-message-id={msg.id}
       data-selected={state.isSelected ? "true" : "false"}
-      style={{ "--chat-hover-bg": hoverBg(), minWidth: 0 }}
+      style={{ "--chat-hover-bg": hoverBg(themeColors), minWidth: 0 }}
     >
       {msg.replyTo && (
         <Box

package/src/plugins/builtin/chat/message/profile-popover.test.tsx

@@ -2,11 +2,11 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { act, useEffect } from "react";
 import {
   apiClient,
-  type AccountProfile,
   type ChatUserSummary,
 } from "../../../../api-client";
 import { testRender } from "../../../../renderers/opentui/test-utils";
 import { Box, Text } from "../../../../ui";
+import { makeAccountProfile } from "../test-harness";
 import { useChatProfilePopover } from "../profile-popover";
 import {
   hasPublicChatProfileInfo,
@@ -36,34 +36,6 @@ function makeUser(overrides: Partial<ChatUserSummary>): ChatUserSummary {
   };
 }
 
-function makeAccountProfile(overrides: Partial<AccountProfile> = {}): AccountProfile {
-  return {
-    id: "u1",
-    email: "vince@example.com",
-    emailVerified: true,
-    plan: "pro",
-    username: "vince",
-    name: "Vince",
-    company: "Gloom",
-    title: null,
-    bio: "Made Gloomberb",
-    profilePublic: true,
-    publicEmail: null,
-    xAccount: null,
-    sharedPortfolioId: "broker:ibkr:coldstart",
-    acceptUnknownDms: false,
-    chatEmailNotificationsEnabled: true,
-    portfolioAnalytics: null,
-    syncEnabled: true,
-    weeklyRoundupEnabled: true,
-    positionAlertsEnabled: true,
-    lastSyncAt: null,
-    lastRoundupEmailAt: null,
-    updatedAt: "2026-07-21T22:03:59.832Z",
-    ...overrides,
-  };
-}
-
 function OwnProfileHarness({ user }: { user: ChatUserSummary }) {
   const {
     profilePopoverUser,

package/src/plugins/builtin/chat/profile-popover.ts

@@ -23,8 +23,23 @@ function accountProfileToChatUser(profile: AccountProfile): ChatUserSummary {
   };
 }
 
-export function useChatProfilePopover() {
+const OPTIONAL_PROFILE_FIELDS = [
+  "company",
+  "title",
+  "bio",
+  "publicEmail",
+  "xAccount",
+  "sharedPortfolioId",
+] as const;
+
+/** `profilePublic` is a visibility switch, not a completion test: any filled optional field counts as set up. */
+export function isAccountProfileConfigured(profile: AccountProfile): boolean {
+  return OPTIONAL_PROFILE_FIELDS.some((field) => (profile[field] ?? "").trim().length > 0);
+}
+
+export function useChatProfilePopover(trackOwnProfileUserId?: string) {
   const [profilePopoverUser, setProfilePopoverUser] = useState<ChatUserSummary | null>(null);
+  const [ownProfileConfigured, setOwnProfileConfigured] = useState<boolean | null>(null);
   const profilePopoverCloseTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const ownProfileRef = useRef<ChatUserSummary | null>(null);
   const ownProfileRequestRef = useRef<Promise<void> | null>(null);
@@ -50,34 +65,25 @@ export function useChatProfilePopover() {
     }, PROFILE_POPOVER_CLOSE_DELAY_MS);
   }, [cancelProfilePopoverClose]);
 
-  const showProfilePopover = useCallback((
-    targetUser: ChatUserSummary,
-    options?: { ownProfile?: boolean },
-  ) => {
-    const ownProfile = options?.ownProfile === true;
-    const cachedUser = ownProfile && ownProfileRef.current?.id === targetUser.id
-      ? ownProfileRef.current
-      : targetUser;
-    if (!ownProfile && !hasPublicChatProfileInfo(cachedUser)) {
-      closeProfilePopover();
-      return;
-    }
-    cancelProfilePopoverClose();
-    setProfilePopoverUser(cachedUser);
-
+  const refreshOwnProfile = useCallback((expectedUserId?: string, force = false) => {
     if (
-      !ownProfile
-      || !apiClient.getSessionToken()
+      !apiClient.isSignedIn()
       || ownProfileRequestRef.current
-      || (ownProfileRef.current?.id === targetUser.id && Date.now() - ownProfileLoadedAtRef.current < 10_000)
+      || (
+        !force
+        && ownProfileRef.current
+        && (!expectedUserId || ownProfileRef.current.id === expectedUserId)
+        && Date.now() - ownProfileLoadedAtRef.current < 10_000
+      )
     ) return;
     const request = apiClient.getAccountProfile()
       .then((profile) => {
-        if (!activeRef.current || profile.id !== targetUser.id) return;
+        if (!activeRef.current || (expectedUserId && profile.id !== expectedUserId)) return;
         const nextUser = accountProfileToChatUser(profile);
         ownProfileRef.current = nextUser;
         ownProfileLoadedAtRef.current = Date.now();
-        setProfilePopoverUser((current) => current?.id === targetUser.id ? nextUser : current);
+        setOwnProfileConfigured(isAccountProfileConfigured(profile));
+        setProfilePopoverUser((current) => current?.id === profile.id ? nextUser : current);
       })
       .catch(() => {})
       .finally(() => {
@@ -86,7 +92,24 @@ export function useChatProfilePopover() {
         }
       });
     ownProfileRequestRef.current = request;
-  }, [cancelProfilePopoverClose, closeProfilePopover]);
+  }, []);
+
+  const showProfilePopover = useCallback((
+    targetUser: ChatUserSummary,
+    options?: { ownProfile?: boolean },
+  ) => {
+    const ownProfile = options?.ownProfile === true;
+    const cachedUser = ownProfile && ownProfileRef.current?.id === targetUser.id
+      ? ownProfileRef.current
+      : targetUser;
+    if (!ownProfile && !hasPublicChatProfileInfo(cachedUser)) {
+      closeProfilePopover();
+      return;
+    }
+    cancelProfilePopoverClose();
+    setProfilePopoverUser(cachedUser);
+    if (ownProfile) refreshOwnProfile(targetUser.id);
+  }, [cancelProfilePopoverClose, closeProfilePopover, refreshOwnProfile]);
 
   useEffect(() => {
     activeRef.current = true;
@@ -96,9 +119,17 @@ export function useChatProfilePopover() {
     };
   }, [cancelProfilePopoverClose]);
 
+  // Force a refresh when the pane regains focus so returning from Account Management settles the answer.
+  useEffect(() => {
+    if (!trackOwnProfileUserId) return;
+    if (ownProfileRef.current?.id !== trackOwnProfileUserId) setOwnProfileConfigured(null);
+    refreshOwnProfile(trackOwnProfileUserId, true);
+  }, [refreshOwnProfile, trackOwnProfileUserId]);
+
   return {
     cancelProfilePopoverClose,
     closeProfilePopover,
+    ownProfileConfigured,
     profilePopoverUser,
     scheduleProfilePopoverClose,
     showProfilePopover,

package/src/plugins/builtin/chat/sidebar.test.tsx

@@ -11,6 +11,10 @@ import { gloomberbCloudPlugin } from "../cloud";
 import { ChatContent } from "./content";
 import { chatController } from "./controller";
 import { useChatChannelNavigation } from "./content/channel-navigation";
+import {
+  subscribeRequestedAccountManagementTab,
+  type AccountManagementTab,
+} from "../account-management/navigation";
 import {
   cleanupChatTest,
   createChatTestControls,
@@ -19,6 +23,7 @@ import {
   installChatApiTestDefaults,
   installServerChannels,
   lineText,
+  makeAccountProfile,
   makeMessage,
   MemoryPersistence,
   type ChatTestSetup,
@@ -312,6 +317,82 @@ describe("ChatContent channel sidebar", () => {
     expect(setup().captureCharFrame()).toContain("● 6 online");
   });
 
+  test("offers a sidebar profile shortcut only until the account profile is filled in", async () => {
+    const controller = createController({ sessionToken: "token-123" });
+    installServerChannels(controller);
+    controller.refreshChannels = async () => {};
+    controller.refreshChannelMessages = async () => {};
+    const originalGetAccountProfile = apiClient.getAccountProfile.bind(apiClient);
+    apiClient.getAccountProfile = async () => makeAccountProfile({
+      id: "u0",
+      company: null,
+      title: null,
+      bio: null,
+      publicEmail: null,
+      xAccount: null,
+      // Set, and deliberately not part of the completion test.
+      profilePublic: true,
+      sharedPortfolioId: null,
+    });
+    const requestedTabs: AccountManagementTab[] = [];
+    const unsubscribe = subscribeRequestedAccountManagementTab((tab) => requestedTabs.push(tab));
+    const shownPanes: string[] = [];
+    const runtime = createTestPluginRuntime({
+      showPane: (paneId: string) => {
+        shownPanes.push(paneId);
+      },
+    });
+
+    try {
+      await act(async () => {
+        testSetup = await testRender(createHarness(controller, { width: 90, height: 14, runtime }), {
+          width: 90,
+          height: 14,
+        });
+      });
+      await flushFrame();
+      await flushFrame();
+
+      const lines = setup().captureCharFrame().split("\n");
+      const row = lines.findIndex((line) => line.includes("@ Profile"));
+      const col = lines[row]?.indexOf("Profile") ?? -1;
+      expect(row).toBeGreaterThanOrEqual(0);
+
+      await act(async () => {
+        await setup().mockMouse.click(col + 1, row);
+        await setup().renderOnce();
+        await setup().renderOnce();
+      });
+      await flushFrame();
+
+      expect(requestedTabs).toEqual(["profile"]);
+      expect(shownPanes).toEqual(["account-management"]);
+
+      apiClient.getAccountProfile = async () => makeAccountProfile({
+        id: "u0",
+        company: null,
+        title: "Trader",
+        bio: null,
+        profilePublic: false,
+        sharedPortfolioId: null,
+      });
+      await act(async () => {
+        testSetup?.renderer.destroy();
+        testSetup = await testRender(createHarness(controller, { width: 90, height: 14, runtime }), {
+          width: 90,
+          height: 14,
+        });
+      });
+      await flushFrame();
+      await flushFrame();
+
+      expect(setup().captureCharFrame()).not.toContain("@ Profile");
+    } finally {
+      unsubscribe();
+      apiClient.getAccountProfile = originalGetAccountProfile;
+    }
+  });
+
   test("uses arrows to move between channel sidebar and chat content", async () => {
     const controller = createController({ sessionToken: "token-123" });
     installServerChannels(controller);