gloomberb 0.3.7 → 0.4.0

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

@@ -1,5 +1,6 @@
 import type { PluginPersistence, PluginResumeState } from "../../types/plugin";
 import { apiClient, type ChatMessage, type PersistedAuthUser } from "../../utils/api-client";
+import { toTimestampMillis } from "../../utils/timestamp";
 
 const SESSION_STATE_KEY = "session";
 const CHANNEL_STATE_KEY = "channel:everyone";
@@ -8,12 +9,15 @@ const TRANSCRIPT_SOURCE = "server";
 const MAX_CACHED_MESSAGES = 50;
 const SESSION_SCHEMA_VERSION = 1;
 const CHANNEL_SCHEMA_VERSION = 1;
-const TRANSCRIPT_SCHEMA_VERSION = 1;
+const TRANSCRIPT_SCHEMA_VERSION = 2;
 const TRANSCRIPT_CACHE_POLICY = {
   staleMs: 30 * 24 * 60 * 60_000,
   expireMs: 90 * 24 * 60 * 60_000,
 };
 const VERIFICATION_POLL_MS = 5_000;
+const ISO_TIMESTAMP_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+const USERNAME_MENTION = /(^|[^A-Za-z0-9_])@([A-Za-z][A-Za-z0-9_]{2,29})(?![A-Za-z0-9_])/g;
+const PENDING_RECONCILE_WINDOW_MS = 2 * 60_000;
 
 interface PersistedSessionState {
   sessionToken: string | null;
@@ -25,6 +29,7 @@ interface PersistedChannelState {
   draft: string;
   replyToId: string | null;
   lastCursor: string | null;
+  lastViewedMessageId?: string | null;
 }
 
 interface PersistedTranscript {
@@ -38,9 +43,45 @@ export interface ChatControllerSnapshot {
   messages: ChatMessage[];
   draft: string;
   replyToId: string | null;
+  unreadMentionCount: number;
 }
 
-type ChatConnection = { send: (content: string, replyToId?: string) => void; close: () => void };
+type ChatConnection = { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void };
+type ChatToastOptions = { duration?: number; type?: "info" | "success" | "error" };
+
+function normalizeUsername(username: string | null | undefined): string | null {
+  const trimmed = username?.trim();
+  return trimmed ? trimmed.toLowerCase() : null;
+}
+
+function messageMentionsUsername(content: string, username: string): boolean {
+  USERNAME_MENTION.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = USERNAME_MENTION.exec(content)) !== null) {
+    if ((match[2] ?? "").toLowerCase() === username) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function formatMentionToast(message: ChatMessage): string {
+  const author = message.user.username || "Someone";
+  const normalized = message.content.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return `@${author} mentioned you in chat.`;
+  }
+  const snippet = normalized.length > 72 ? `${normalized.slice(0, 69)}...` : normalized;
+  return `@${author} mentioned you: ${snippet}`;
+}
+
+function isLegacyTimestampCursor(cursor: string | null): boolean {
+  return !!cursor && ISO_TIMESTAMP_CURSOR.test(cursor);
+}
+
+function compareMessages(a: ChatMessage, b: ChatMessage): number {
+  return a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id);
+}
 
 export class ChatController {
   private persistence: PluginPersistence | null = null;
@@ -48,14 +89,21 @@ export class ChatController {
   private appActive = true;
   private hydrated = false;
   private sessionChecked = false;
+  private messagesLoading = false;
+  private refreshMessagesPromise: Promise<void> | null = null;
   private user: { id: string; username: string; emailVerified: boolean } | null = null;
   private messages: ChatMessage[] = [];
+  private pendingMessages: ChatMessage[] = [];
   private draft = "";
   private replyToId: string | null = null;
   private lastCursor: string | null = null;
+  private lastViewedMessageId: string | null = null;
   private wsConnection: ChatConnection | null = null;
   private wsConnected = false;
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
+  private openViewCount = 0;
+  private pendingMessageSeq = 0;
+  private toastFn: (message: string, options?: ChatToastOptions) => void = () => {};
   private listeners = new Set<(snapshot: ChatControllerSnapshot) => void>();
 
   attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
@@ -64,6 +112,10 @@ export class ChatController {
     this.hydrate();
   }
 
+  setToastNotifier(notify: (message: string, options?: ChatToastOptions) => void): void {
+    this.toastFn = notify;
+  }
+
   hydrate(): void {
     if (this.hydrated || !this.persistence) return;
     this.hydrated = true;
@@ -92,7 +144,8 @@ export class ChatController {
     });
     this.draft = channel?.draft ?? "";
     this.replyToId = channel?.replyToId ?? null;
-    this.lastCursor = channel?.lastCursor ?? null;
+    const persistedCursor = channel?.lastCursor ?? null;
+    const persistedViewedMessageId = channel?.lastViewedMessageId ?? null;
 
     const transcript = this.persistence.getResource<PersistedTranscript>(TRANSCRIPT_KIND, "everyone", {
       sourceKey: TRANSCRIPT_SOURCE,
@@ -100,6 +153,12 @@ export class ChatController {
       allowExpired: true,
     });
     this.messages = transcript?.value.messages ?? [];
+    this.lastCursor = this.messages.length > 0
+      ? persistedCursor ?? this.messages[this.messages.length - 1]?.id ?? null
+      : null;
+    this.lastViewedMessageId = this.user?.id && apiClient.getSessionToken()
+      ? persistedViewedMessageId ?? this.messages[this.messages.length - 1]?.id ?? null
+      : null;
     this.syncVerificationPolling();
   }
 
@@ -113,12 +172,13 @@ export class ChatController {
 
   getSnapshot(): ChatControllerSnapshot {
     return {
-      loading: !this.sessionChecked,
+      loading: !this.sessionChecked || this.messagesLoading,
       hasSavedSession: !!apiClient.getSessionToken(),
       user: this.user,
-      messages: [...this.messages],
+      messages: this.getVisibleMessages(),
       draft: this.draft,
       replyToId: this.replyToId,
+      unreadMentionCount: this.getUnreadMentionCount(),
     };
   }
 
@@ -126,18 +186,42 @@ export class ChatController {
     const token = apiClient.getSessionToken();
     if (!token) {
       this.stopVerificationPolling();
+      this.wsConnection?.close();
+      this.wsConnection = null;
+      this.wsConnected = false;
       this.user = null;
       this.sessionChecked = true;
+      this.pendingMessages = [];
+      this.lastViewedMessageId = null;
       this.persistSession();
       this.emit();
       return;
     }
 
     const session = await apiClient.getSession();
-    const nextUser = session
-      ? { id: session.id, username: session.username ?? session.name, emailVerified: !!session.emailVerified }
-      : null;
+    if (!session) {
+      this.stopVerificationPolling();
+      this.wsConnection?.close();
+      this.wsConnection = null;
+      this.wsConnected = false;
+      apiClient.setSessionToken(null);
+      this.user = null;
+      this.sessionChecked = true;
+      this.pendingMessages = [];
+      this.lastViewedMessageId = null;
+      this.persistSession();
+      this.emit();
+      return;
+    }
+
+    const previousIdentity = `${this.user?.id ?? ""}:${normalizeUsername(this.user?.username) ?? ""}`;
+    const nextUser = { id: session.id, username: session.username ?? session.name, emailVerified: !!session.emailVerified };
     this.user = nextUser;
+    const nextIdentity = `${nextUser.id}:${normalizeUsername(nextUser.username) ?? ""}`;
+    if (previousIdentity && previousIdentity !== nextIdentity) {
+      this.lastViewedMessageId = this.messages[this.messages.length - 1]?.id ?? null;
+      this.persistChannelState();
+    }
     this.sessionChecked = true;
     this.persistSession();
     this.emit();
@@ -152,10 +236,26 @@ export class ChatController {
     this.wsConnection?.close();
     this.wsConnection = null;
     this.wsConnected = false;
-    if (!nextUser) {
-      this.stopVerificationPolling();
-      this.reset(true);
-    }
+  }
+
+  async refreshMessages(): Promise<void> {
+    if (this.refreshMessagesPromise) return this.refreshMessagesPromise;
+
+    this.messagesLoading = true;
+    this.emit();
+
+    const request = this.fetchMessages()
+      .catch(() => {
+        this.persistChannelState();
+      })
+      .finally(() => {
+        this.messagesLoading = false;
+        this.refreshMessagesPromise = null;
+        this.emit();
+      });
+
+    this.refreshMessagesPromise = request;
+    return request;
   }
 
   setDraft(draft: string): void {
@@ -170,6 +270,16 @@ export class ChatController {
     this.emit();
   }
 
+  attachView(): () => void {
+    this.openViewCount += 1;
+    if (this.markViewedThroughLatestMessage()) {
+      this.emit();
+    }
+    return () => {
+      this.openViewCount = Math.max(0, this.openViewCount - 1);
+    };
+  }
+
   clearSession(): void {
     this.stopVerificationPolling();
     this.wsConnection?.close();
@@ -177,6 +287,8 @@ export class ChatController {
     this.wsConnected = false;
     this.user = null;
     this.sessionChecked = false;
+    this.pendingMessages = [];
+    this.lastViewedMessageId = null;
     this.emit();
   }
 
@@ -196,9 +308,12 @@ export class ChatController {
     this.wsConnection = null;
     this.wsConnected = false;
     this.messages = [];
+    this.pendingMessages = [];
     this.draft = "";
     this.replyToId = null;
     this.lastCursor = null;
+    this.lastViewedMessageId = null;
+    this.openViewCount = 0;
     if (clearSession) {
       this.user = null;
       apiClient.setSessionToken(null);
@@ -212,32 +327,43 @@ export class ChatController {
   }
 
   send(content: string, replyToId?: string): void {
-    this.wsConnection?.send(content, replyToId);
-    this.setDraft("");
-    this.setReplyToId(null);
+    if (!this.user?.emailVerified || !apiClient.getSessionToken()) return;
+    if (!this.wsConnection && this.user?.emailVerified && apiClient.getSessionToken()) {
+      this.ensureConnection();
+    }
+    const connection = this.wsConnection;
+    if (!connection) {
+      this.toastFn("Unable to send message right now.", { type: "error" });
+      return;
+    }
+
+    const pendingMessage = this.createPendingMessage(content, replyToId);
+    this.pendingMessages = [...this.pendingMessages, pendingMessage];
+    this.draft = "";
+    this.replyToId = null;
+    this.persistChannelState();
+    this.emit();
+
+    void connection.send(content, replyToId).then((message) => {
+      this.pendingMessages = this.pendingMessages.filter((entry) => entry.id !== pendingMessage.id);
+      this.mergeMessages([message]);
+    }).catch((error) => {
+      const errorMessage = error instanceof Error && error.message ? error.message : "Failed to send message.";
+      this.pendingMessages = this.pendingMessages.map((entry) => (
+        entry.id === pendingMessage.id
+          ? { ...entry, clientStatus: "failed", clientError: errorMessage }
+          : entry
+      ));
+      this.emit();
+      this.toastFn(errorMessage, { type: "error" });
+    });
   }
 
   ensureConnection(): void {
     if (this.wsConnected || !this.user?.emailVerified || !apiClient.getSessionToken()) return;
     this.wsConnected = true;
 
-    apiClient.getMessages("everyone", {
-      limit: MAX_CACHED_MESSAGES,
-      after: this.lastCursor ?? undefined,
-    }).then((messages) => {
-      if (messages.length > 0) {
-        this.mergeMessages(messages);
-        return;
-      }
-      this.persistChannelState();
-    }).catch(async () => {
-      try {
-        const messages = await apiClient.getMessages("everyone", { limit: MAX_CACHED_MESSAGES });
-        this.mergeMessages(messages);
-      } catch {
-        // keep local transcript
-      }
-    });
+    void this.refreshMessages().catch(() => {});
 
     this.wsConnection = apiClient.connectChannel(
       "everyone",
@@ -279,14 +405,57 @@ export class ChatController {
     this.verificationPollTimer = null;
   }
 
+  private async fetchMessages(): Promise<void> {
+    const legacyTimestampCursor = isLegacyTimestampCursor(this.lastCursor);
+
+    try {
+      const messages = await apiClient.getMessages("everyone", {
+        limit: MAX_CACHED_MESSAGES,
+        after: this.lastCursor ?? undefined,
+      });
+      if (messages.length > 0) {
+        this.mergeMessages(messages);
+        return;
+      }
+      if (legacyTimestampCursor) {
+        const fullRefresh = await apiClient.getMessages("everyone", { limit: MAX_CACHED_MESSAGES });
+        if (fullRefresh.length > 0) {
+          this.mergeMessages(fullRefresh);
+          return;
+        }
+        this.lastCursor = null;
+      }
+      this.persistChannelState();
+      return;
+    } catch {
+      const messages = await apiClient.getMessages("everyone", { limit: MAX_CACHED_MESSAGES });
+      if (messages.length > 0) {
+        this.mergeMessages(messages);
+        return;
+      }
+      this.persistChannelState();
+    }
+  }
+
   private mergeMessages(messages: ChatMessage[]): void {
+    this.reconcilePendingMessages(messages);
     const merged = new Map<string, ChatMessage>();
+    const incoming = new Map<string, ChatMessage>();
     for (const message of this.messages) merged.set(message.id, message);
-    for (const message of messages) merged.set(message.id, message);
+    for (const message of messages) {
+      if (!merged.has(message.id)) {
+        incoming.set(message.id, message);
+      }
+      merged.set(message.id, message);
+    }
     this.messages = [...merged.values()]
-      .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+      .sort(compareMessages)
       .slice(-MAX_CACHED_MESSAGES);
-    this.lastCursor = this.messages[this.messages.length - 1]?.createdAt ?? this.lastCursor;
+    this.lastCursor = this.messages[this.messages.length - 1]?.id ?? this.lastCursor;
+    if (this.openViewCount > 0) {
+      this.markViewedThroughLatestMessage(false);
+    }
+    this.trackUnreadMentions([...incoming.values()]);
     this.persistTranscript();
     this.emit();
   }
@@ -310,6 +479,7 @@ export class ChatController {
       draft: this.draft,
       replyToId: this.replyToId,
       lastCursor: this.lastCursor,
+      lastViewedMessageId: this.lastViewedMessageId,
     } satisfies PersistedChannelState;
     this.resume?.setState(CHANNEL_STATE_KEY, value, {
       schemaVersion: CHANNEL_SCHEMA_VERSION,
@@ -335,6 +505,111 @@ export class ChatController {
     });
     this.persistChannelState();
   }
+
+  private trackUnreadMentions(messages: ChatMessage[]): void {
+    if (this.openViewCount > 0) {
+      return;
+    }
+
+    const freshMentions = this.getMentionMessages(messages);
+    if (freshMentions.length === 0) return;
+    if (!this.appActive) return;
+
+    if (freshMentions.length === 1) {
+      this.toastFn(formatMentionToast(freshMentions[0]!), { type: "info" });
+      return;
+    }
+    this.toastFn(`${freshMentions.length} new mentions in #everyone.`, { type: "info" });
+  }
+
+  private getUnreadMentionCount(): number {
+    return this.getUnreadMentionMessages().length;
+  }
+
+  private getUnreadMentionMessages(): ChatMessage[] {
+    if (!this.lastViewedMessageId) {
+      return this.getMentionMessages(this.messages);
+    }
+
+    const viewedIndex = this.messages.findIndex((message) => message.id === this.lastViewedMessageId);
+    const unseenMessages = viewedIndex >= 0
+      ? this.messages.slice(viewedIndex + 1)
+      : this.messages;
+    return this.getMentionMessages(unseenMessages);
+  }
+
+  private getMentionMessages(messages: ChatMessage[]): ChatMessage[] {
+    const normalizedUsername = normalizeUsername(this.user?.username);
+    if (!normalizedUsername || messages.length === 0) return [];
+
+    return messages.filter((message) => (
+      message.user.id !== this.user?.id && messageMentionsUsername(message.content, normalizedUsername)
+    ));
+  }
+
+  private markViewedThroughLatestMessage(persist = true): boolean {
+    const latestMessageId = this.messages[this.messages.length - 1]?.id ?? null;
+    if (this.lastViewedMessageId === latestMessageId) {
+      return false;
+    }
+    this.lastViewedMessageId = latestMessageId;
+    if (persist) {
+      this.persistChannelState();
+    }
+    return true;
+  }
+
+  private getVisibleMessages(): ChatMessage[] {
+    return [...this.messages, ...this.pendingMessages]
+      .sort(compareMessages)
+      .slice(-MAX_CACHED_MESSAGES);
+  }
+
+  private createPendingMessage(content: string, replyToId?: string): ChatMessage {
+    const replyToMessage = replyToId
+      ? this.getVisibleMessages().find((message) => message.id === replyToId) ?? null
+      : null;
+    const pendingId = `local:${Date.now()}:${this.pendingMessageSeq += 1}`;
+    return {
+      id: pendingId,
+      channelId: "everyone",
+      content,
+      replyToId: replyToId ?? null,
+      createdAt: new Date().toISOString(),
+      user: {
+        id: this.user?.id ?? "local",
+        username: this.user?.username ?? "you",
+        displayName: this.user?.username ?? "You",
+      },
+      replyTo: replyToMessage
+        ? {
+          content: replyToMessage.content,
+          user: { username: replyToMessage.user.username },
+        }
+        : null,
+      clientStatus: "sending",
+      clientError: null,
+    };
+  }
+
+  private reconcilePendingMessages(messages: ChatMessage[]): void {
+    if (this.pendingMessages.length === 0 || messages.length === 0) return;
+
+    const remaining = [...this.pendingMessages];
+    for (const incoming of messages) {
+      const incomingMs = toTimestampMillis(incoming.createdAt);
+      const pendingIndex = remaining.findIndex((pending) => (
+        pending.user.id === incoming.user.id
+        && pending.content === incoming.content
+        && pending.replyToId === incoming.replyToId
+        && Math.abs(toTimestampMillis(pending.createdAt) - incomingMs) <= PENDING_RECONCILE_WINDOW_MS
+      ));
+      if (pendingIndex >= 0) {
+        remaining.splice(pendingIndex, 1);
+      }
+    }
+    this.pendingMessages = remaining;
+  }
 }
 
 export const chatController = new ChatController();

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

@@ -13,6 +13,8 @@ import { ChatController } from "./chat-controller";
 const TRANSCRIPT_KIND = "channel-transcript";
 const TRANSCRIPT_KEY = "everyone";
 const TRANSCRIPT_SOURCE = "server";
+const TRANSCRIPT_SCHEMA_VERSION = 2;
+const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -115,17 +117,18 @@ function createController(options: {
   persistence.setState("channel:everyone", {
     draft: "",
     replyToId: null,
-    lastCursor: messages[messages.length - 1]?.createdAt ?? null,
+    lastCursor: messages[messages.length - 1]?.id ?? null,
   }, { schemaVersion: 1 });
   if (messages.length > 0) {
     persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, { messages }, {
       sourceKey: TRANSCRIPT_SOURCE,
-      schemaVersion: 1,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
       cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
     });
   }
   controller.attachPersistence(persistence);
   controller.refreshSession = async () => {};
+  controller.refreshMessages = async () => {};
   return controller;
 }
 
@@ -164,6 +167,7 @@ async function flushFrame() {
 afterEach(async () => {
   setSharedRegistryForTests(undefined);
   setSharedDataProviderForTests(undefined);
+  apiClient.connectChannel = originalConnectChannel;
   apiClient.setSessionToken(null);
 
   if (testSetup) {
@@ -211,6 +215,34 @@ describe("ChatContent", () => {
     expect(frameAfterType).not.toContain("> FCD");
   });
 
+  test("renders optimistic sends with a sending status", async () => {
+    const controller = createController({
+      messages: [{
+        id: "local:1",
+        channelId: "everyone",
+        content: "hello",
+        replyToId: null,
+        createdAt: "2026-03-28T00:00:00.000Z",
+        user: { id: "u0", username: "vince", displayName: "Vince" },
+        clientStatus: "sending",
+        clientError: null,
+      }],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const frameAfterSubmit = testSetup.captureCharFrame();
+    expect(frameAfterSubmit).toContain("hello");
+    expect(frameAfterSubmit).toContain("sending...");
+  });
+
   test("auto-scrolls to newly appended messages while following the latest transcript", async () => {
     const controller = createController({
       messages: [
@@ -323,7 +355,7 @@ describe("ChatContent", () => {
     expect(opened).toEqual(["TSLA"]);
   });
 
-  test("shows a saved-login message instead of logged out when a session token is cached", async () => {
+  test("shows a saved-login read-only footer when a session token is cached", async () => {
     const controller = createController({
       sessionToken: "token-123",
       user: null,
@@ -340,8 +372,33 @@ describe("ChatContent", () => {
 
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("Saved login found.");
-    expect(frame).toContain("Reconnect to refresh");
-    expect(frame).not.toContain("Not logged in.");
+    expect(frame).toContain("Log in again to send.");
+    expect(frame).toContain("No messages yet.");
+    expect(frame).not.toContain("Type a message...");
+  });
+
+  test("keeps the transcript visible for logged-out users and blocks the composer", async () => {
+    const controller = createController({
+      sessionToken: null,
+      user: null,
+      messages: [makeMessage(1)],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("message 1");
+    expect(frame).toContain("Read-only chat.");
+    expect(frame).toContain("Login");
+    expect(frame).toContain("Sign Up");
+    expect(frame).not.toContain("Type a message...");
   });
 
   test("shows a logged-in icon in the cloud status widget for cached sessions", async () => {
@@ -365,7 +422,7 @@ describe("ChatContent", () => {
 
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("@");
-    expect(frame).toContain("Shift+C");
+    expect(frame).not.toContain("Shift+C");
     expect(frame).not.toContain("vince");
   });
 
@@ -415,6 +472,61 @@ describe("ChatContent", () => {
     expect(openedQueries).toEqual(["Sign Up"]);
   });
 
+  test("shows an unread mention badge and opens chat from the status widget", async () => {
+    const controller = createController({
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    });
+    const openedWidgets: string[] = [];
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
+    state.config.disabledPlugins = [];
+
+    setSharedRegistryForTests({
+      showWidget(paneId: string) {
+        openedWidgets.push(paneId);
+      },
+    } as any);
+
+    await act(async () => {
+      (controller as any).mergeMessages([{
+        id: "m1",
+        channelId: "everyone",
+        content: "pinging @vince before the bell",
+        replyToId: null,
+        createdAt: "2026-03-28T00:00:00.000Z",
+        user: { id: "u2", username: "bob", displayName: "Bob" },
+      } satisfies ChatMessage]);
+    });
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <ChatStatusWidget controller={controller} />
+        </AppContext>,
+        { width: 40, height: 1 },
+      );
+    });
+
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("vince");
+    expect(frame).toContain("[1]");
+
+    const line = frame.split("\n")[0] ?? "";
+    const badgeCol = line.indexOf("[1]");
+
+    expect(badgeCol).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(badgeCol + 1, 0);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(openedWidgets).toEqual(["chat"]);
+  });
+
   test("auth commands use a single-form layout and signup no longer prompts for display name", () => {
     const registeredCommands: Array<{ id: string; wizardLayout?: string; wizard?: Array<{ key: string }> }> = [];