gloomberb 0.7.2 → 0.7.3

package/src/plugins/builtin/broker-manager/index.tsx

@@ -32,6 +32,7 @@ import type { GloomPlugin, PaneProps } from "../../../types/plugin";
 import type { BrokerAccount } from "../../../types/trading";
 import { useDialog, type PromptContext } from "../../../ui/dialog";
 import { formatCurrency } from "../../../utils/format";
+import { isPlainKey } from "../../../utils/keyboard";
 import { usePluginAppActions, usePluginBrokerActions } from "../../plugin-runtime";
 import {
   buildBrokerProfileRows,
@@ -47,7 +48,7 @@ type BrokerColumn = DataTableColumn & { id: BrokerColumnId };
 function stateColor(state: BrokerDisplayState): string {
   switch (state) {
     case "connected": return colors.positive;
-    case "connecting": return "#e5c07b";
+    case "connecting": return colors.warning;
     case "error": return colors.negative;
     case "disabled": return colors.textMuted;
     case "unavailable": return colors.negative;
@@ -442,13 +443,13 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
         saveEdit().catch(() => {});
         return;
       }
-      if (event.name === "up" || event.name === "k") {
+      if (isPlainKey(event, "up", "k")) {
         event.stopPropagation();
         const index = editKeys.indexOf(activeEditKey);
         setActiveEditKey(editKeys[Math.max(0, index - 1)] ?? "label");
         return;
       }
-      if (event.name === "down" || event.name === "j" || event.name === "tab") {
+      if (isPlainKey(event, "down", "j", "tab")) {
         event.stopPropagation();
         const index = editKeys.indexOf(activeEditKey);
         setActiveEditKey(editKeys[Math.min(editKeys.length - 1, index + 1)] ?? "label");

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

@@ -1,7 +1,7 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import type { AppNotificationRequest, PluginPersistence } from "../../types/plugin";
 import type { PersistedResourceValue } from "../../types/persistence";
-import { apiClient, type ChatChannel, type ChatMessage } from "../../utils/api-client";
+import { apiClient, type ChatChannel, type ChatMessage, type ChatNotification } from "../../utils/api-client";
 import { ChatController } from "./chat-controller";
 
 const TRANSCRIPT_KIND = "channel-transcript";
@@ -12,6 +12,12 @@ const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
 const originalGetSession = apiClient.getSession.bind(apiClient);
 const originalGetMessages = apiClient.getMessages.bind(apiClient);
 const originalGetChannels = apiClient.getChannels.bind(apiClient);
+const originalGetChatPresence = apiClient.getChatPresence.bind(apiClient);
+const originalGetChatState = apiClient.getChatState.bind(apiClient);
+const originalUpdateChatChannelState = apiClient.updateChatChannelState.bind(apiClient);
+const originalMarkChatNotificationsDelivered = apiClient.markChatNotificationsDelivered.bind(apiClient);
+const originalSubscribeChatNotifications = apiClient.subscribeChatNotifications.bind(apiClient);
+const originalSubscribeChatPresence = apiClient.subscribeChatPresence.bind(apiClient);
 
 const SERVER_CHAT_CHANNELS: ChatChannel[] = [
   { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
@@ -100,6 +106,30 @@ class TrackingPersistence extends MemoryPersistence {
   }
 }
 
+beforeEach(() => {
+  apiClient.getChatPresence = async () => ({ onlineCount: 0 });
+  apiClient.getChatState = async () => ({
+    channels: SERVER_CHAT_CHANNELS,
+    onlineCount: 0,
+    channelStates: SERVER_CHAT_CHANNELS.map((channel) => ({
+      channelId: channel.id,
+      notificationsEnabled: false,
+      lastReadMessageId: null,
+      unreadCount: 0,
+    })),
+    notifications: [],
+  });
+  apiClient.updateChatChannelState = async (channelId, body) => ({
+    channelId,
+    notificationsEnabled: body.notificationsEnabled ?? false,
+    lastReadMessageId: body.readThroughMessageId ?? null,
+    unreadCount: 0,
+  });
+  apiClient.markChatNotificationsDelivered = async () => ({ delivered: 1 });
+  apiClient.subscribeChatNotifications = () => () => {};
+  apiClient.subscribeChatPresence = () => () => {};
+});
+
 afterEach(() => {
   apiClient.dispose();
   apiClient.setSessionToken(null);
@@ -107,6 +137,12 @@ afterEach(() => {
   apiClient.getSession = originalGetSession;
   apiClient.getMessages = originalGetMessages;
   apiClient.getChannels = originalGetChannels;
+  apiClient.getChatPresence = originalGetChatPresence;
+  apiClient.getChatState = originalGetChatState;
+  apiClient.updateChatChannelState = originalUpdateChatChannelState;
+  apiClient.markChatNotificationsDelivered = originalMarkChatNotificationsDelivered;
+  apiClient.subscribeChatNotifications = originalSubscribeChatNotifications;
+  apiClient.subscribeChatPresence = originalSubscribeChatPresence;
 });
 
 describe("ChatController", () => {
@@ -280,6 +316,7 @@ describe("ChatController", () => {
     const controller = new ChatController();
 
     apiClient.setSessionToken("token-123");
+    (controller as any).sessionToken = "token-123";
     (controller as any).user = { id: "u1", username: "vince", emailVerified: false };
 
     controller.setAppActive(false);
@@ -297,6 +334,7 @@ describe("ChatController", () => {
     let closed = false;
 
     apiClient.setSessionToken("token-123");
+    (controller as any).sessionToken = "token-123";
     (controller as any).user = { id: "u1", username: "vince", emailVerified: false };
     (controller as any).syncVerificationPolling();
     expect((controller as any).verificationPollTimer).not.toBeNull();
@@ -548,6 +586,54 @@ describe("ChatController", () => {
     });
   });
 
+  test("hydrates missing transcript cache without marking history unread", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const history: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "already seen",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "m1",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
+    });
+    controller.attachPersistence(persistence);
+
+    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
+    apiClient.getMessages = async (channelId, opts) => {
+      calls.push({ channelId, opts });
+      return opts?.after ? [] : [history];
+    };
+
+    await controller.refreshMessages();
+
+    expect(calls).toEqual([{
+      channelId: "everyone",
+      opts: { limit: 50, after: undefined },
+    }]);
+    expect(controller.getSnapshot().messages).toEqual([history]);
+    expect(controller.getSnapshot().channelStates.find((entry) => entry.channelId === "everyone")).toMatchObject({
+      unreadCount: 0,
+    });
+    expect(notifications).toEqual([]);
+  });
+
   test("backfills from cached transcript when persisted cursor is ahead of the cache", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -671,6 +757,40 @@ describe("ChatController", () => {
     expect(snapshot.messages).toEqual([replyTarget, sentMessage]);
   });
 
+  test("sends one idempotency key while the same message is pending", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const clientMessageIds: Array<string | undefined> = [];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+    apiClient.getMessages = async () => [];
+    apiClient.connectChannel = () => ({
+      send: (_content, _replyToId, clientMessageId) => {
+        clientMessageIds.push(clientMessageId);
+        return new Promise<ChatMessage>(() => {});
+      },
+      close: () => {},
+    });
+
+    const detachFirstView = controller.attachChannelView("everyone");
+    const detachSecondView = controller.attachChannelView("everyone");
+
+    controller.sendToChannel("everyone", " hello ");
+    controller.sendToChannel("everyone", "hello");
+
+    expect(clientMessageIds).toHaveLength(1);
+    expect(clientMessageIds[0]).toBeTruthy();
+    expect(controller.getSnapshot("everyone").messages).toHaveLength(1);
+
+    detachFirstView();
+    detachSecondView();
+  });
+
   test("marks a pending message as failed when sending errors", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -706,7 +826,7 @@ describe("ChatController", () => {
     expect(notifications).toEqual([{ body: "server offline", type: "error" }]);
   });
 
-  test("tracks unread mentions and emits an app notification while chat is closed", () => {
+  test("tracks unread mentions from fetched messages without issuing local notifications", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
     const notifications: AppNotificationRequest[] = [];
@@ -732,19 +852,14 @@ describe("ChatController", () => {
     (controller as any).mergeMessages([message]);
 
     expect(controller.getSnapshot().unreadMentionCount).toBe(1);
-    expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      body: "@bob mentioned you: hey @Vince can you take a look?",
-      type: "info",
-      desktop: "when-inactive",
-    }]);
+    expect(notifications).toEqual([]);
     expect(persistence.getState<{ lastCursor: string | null; lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastCursor: "m1",
       lastViewedMessageId: null,
     });
   });
 
-  test("keeps emitting mention notifications while the app is backgrounded", () => {
+  test("displays server-issued mention notifications while the app is backgrounded", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
     const notifications: AppNotificationRequest[] = [];
@@ -768,10 +883,18 @@ describe("ChatController", () => {
     controller.attachPersistence(persistence);
     controller.setAppActive(false);
 
-    (controller as any).mergeMessages([message]);
+    (controller as any).handleChatNotification({
+      id: "n1",
+      type: "mention",
+      channelId: "everyone",
+      messageId: "m1",
+      createdAt: "2026-03-28T00:00:00.000Z",
+      message,
+    } satisfies ChatNotification);
 
     expect(notifications).toEqual([{
       title: "Gloomberb chat",
+      subtitle: "#everyone",
       body: "@bob mentioned you: hey @vince",
       type: "info",
       desktop: "when-inactive",
@@ -808,12 +931,7 @@ describe("ChatController", () => {
     const detachView = controller.attachView();
 
     expect(controller.getSnapshot().unreadMentionCount).toBe(0);
-    expect(notifications).toEqual([{
-      title: "Gloomberb chat",
-      body: "@bob mentioned you: hey @vince",
-      type: "info",
-      desktop: "when-inactive",
-    }]);
+    expect(notifications).toEqual([]);
     expect(persistence.getState<{ lastViewedMessageId: string | null }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
       lastViewedMessageId: "m1",
     });
@@ -855,6 +973,269 @@ describe("ChatController", () => {
     detachView();
   });
 
+  test("loads server chat state, pending reply notifications, and acks delivery", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const deliveredIds: string[][] = [];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    apiClient.getSession = async () => ({
+      id: "u1",
+      name: "Vince",
+      email: "vince@example.com",
+      username: "vince",
+      emailVerified: true,
+      image: null,
+      createdAt: "2026-01-01T00:00:00.000Z",
+      updatedAt: "2026-01-01T00:00:00.000Z",
+    });
+    apiClient.getChatState = async () => ({
+      channels: SERVER_CHAT_CHANNELS,
+      onlineCount: 7,
+      channelStates: [{
+        channelId: "options",
+        notificationsEnabled: true,
+        lastReadMessageId: "m1",
+        unreadCount: 3,
+      }],
+      notifications: [{
+        id: "n1",
+        type: "reply",
+        channelId: "options",
+        messageId: "m2",
+        createdAt: "2026-03-28T00:02:00.000Z",
+        message: {
+          id: "m2",
+          channelId: "options",
+          content: "answering you",
+          replyToId: "m1",
+          createdAt: "2026-03-28T00:02:00.000Z",
+          user: { id: "u2", username: "bob", displayName: "Bob" },
+          replyTo: { content: "question", user: { id: "u1", username: "vince" } },
+        },
+      }],
+    });
+    apiClient.markChatNotificationsDelivered = async (ids) => {
+      deliveredIds.push(ids);
+      return { delivered: ids.length };
+    };
+    apiClient.connectChannel = () => ({
+      send: async () => {
+        throw new Error("not implemented");
+      },
+      close: () => {},
+    });
+
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
+    });
+    controller.attachPersistence(persistence);
+
+    await controller.refreshSession();
+
+    expect(controller.getSnapshot("options").onlineCount).toBe(7);
+    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
+      notificationsEnabled: true,
+      unreadCount: 3,
+    });
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      subtitle: "#options",
+      body: "@bob replied to you: answering you",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
+    expect(deliveredIds).toEqual([["n1"]]);
+  });
+
+  test("toggles channel notifications optimistically and keeps the channel connected", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const connectedChannels: string[] = [];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    apiClient.updateChatChannelState = async (channelId, body) => ({
+      channelId,
+      notificationsEnabled: body.notificationsEnabled === true,
+      lastReadMessageId: null,
+      unreadCount: 0,
+    });
+    apiClient.connectChannel = (channelId) => {
+      connectedChannels.push(channelId);
+      return {
+        send: async () => {
+          throw new Error("not implemented");
+        },
+        close: () => {},
+      };
+    };
+
+    controller.attachPersistence(persistence);
+    controller.setChannelNotificationsEnabled("options", true);
+    await flushMicrotasks();
+
+    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
+      notificationsEnabled: true,
+    });
+    expect(connectedChannels).toContain("options");
+  });
+
+  test("dedupes reply notifications by message id", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const notification: ChatNotification = {
+      id: "n1",
+      type: "reply",
+      channelId: "everyone",
+      messageId: "m2",
+      createdAt: "2026-03-28T00:02:00.000Z",
+      message: {
+        id: "m2",
+        channelId: "everyone",
+        content: "same reply",
+        replyToId: "m1",
+        createdAt: "2026-03-28T00:02:00.000Z",
+        user: { id: "u2", username: "bob", displayName: "Bob" },
+        replyTo: { content: "question", user: { id: "u1", username: "vince" } },
+      },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    controller.setNotifier((entry) => {
+      notifications.push(entry);
+    });
+    controller.attachPersistence(persistence);
+
+    (controller as any).handleChatNotification(notification);
+    (controller as any).handleChatNotification({ ...notification, id: "n2" });
+
+    expect(notifications).toHaveLength(1);
+  });
+
+  test("displays server-issued channel notifications", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "options",
+      content: "new option flow",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    controller.setNotifier((entry) => {
+      notifications.push(entry);
+    });
+    controller.attachPersistence(persistence);
+
+    (controller as any).handleChatNotification({
+      id: "n1",
+      type: "channel",
+      channelId: "options",
+      messageId: "m1",
+      createdAt: "2026-03-28T00:00:00.000Z",
+      message,
+    } satisfies ChatNotification);
+
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      subtitle: "#options",
+      body: "#options @bob: new option flow",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
+  });
+
+  test("tracks unread channel messages and clears them when the channel opens", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "options",
+      content: "new option flow",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    controller.attachPersistence(persistence);
+
+    (controller as any).mergeMessages("options", [message]);
+
+    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
+      unreadCount: 1,
+    });
+
+    const detachView = controller.attachChannelView("options");
+
+    expect(controller.getSnapshot("options").channelStates.find((entry) => entry.channelId === "options")).toMatchObject({
+      unreadCount: 0,
+    });
+    detachView();
+  });
+
+  test("server reply notifications fire even when channel notifications are disabled", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const message: ChatMessage = {
+      id: "m2",
+      channelId: "options",
+      content: "reply without channel notify",
+      replyToId: "m1",
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+      replyTo: { content: "question", user: { id: "u1", username: "vince" } },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    controller.setNotifier((notification) => {
+      notifications.push(notification);
+    });
+    controller.attachPersistence(persistence);
+
+    (controller as any).handleChatNotification({
+      id: "n1",
+      type: "reply",
+      channelId: "options",
+      messageId: "m2",
+      createdAt: "2026-03-28T00:00:00.000Z",
+      message,
+    } satisfies ChatNotification);
+
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      subtitle: "#options",
+      body: "@bob replied to you: reply without channel notify",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
+  });
+
   test("recovers from a legacy timestamp cursor by falling back to a full transcript fetch", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();