gloomberb 0.7.2 → 0.7.4

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

@@ -1,5 +1,12 @@
 import type { AppNotificationRequest, PluginPersistence, PluginResumeState } from "../../types/plugin";
-import { apiClient, type ChatChannel, type ChatMessage, type PersistedAuthUser } from "../../utils/api-client";
+import {
+  apiClient,
+  type ChatChannel,
+  type ChatChannelState,
+  type ChatMessage,
+  type ChatNotification,
+  type PersistedAuthUser,
+} from "../../utils/api-client";
 import { debugLog } from "../../utils/debug-log";
 import { toTimestampMillis } from "../../utils/timestamp";
 
@@ -32,6 +39,7 @@ interface PersistedSessionState {
 
 interface PersistedChannelState {
   draft: string;
+  draftClientMessageId?: string | null;
   replyToId: string | null;
   lastCursor: string | null;
   lastViewedMessageId?: string | null;
@@ -44,11 +52,13 @@ interface PersistedTranscript {
 export interface ChatControllerSnapshot {
   channelId: string;
   channels: ChatChannel[];
+  channelStates: ChatChannelState[];
   channelsLoading: boolean;
   loading: boolean;
   loadingOlderMessages: boolean;
   hasOlderMessages: boolean;
   hasSavedSession: boolean;
+  onlineCount: number;
   user: { id: string; username: string; emailVerified: boolean } | null;
   messages: ChatMessage[];
   draft: string;
@@ -56,7 +66,8 @@ export interface ChatControllerSnapshot {
   unreadMentionCount: number;
 }
 
-type ChatConnection = { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void };
+type ChatConnection = { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void };
+type MergeMessagesOptions = { countUnread?: boolean };
 
 interface ChannelRuntimeState {
   hydrated: boolean;
@@ -68,9 +79,12 @@ interface ChannelRuntimeState {
   messages: ChatMessage[];
   pendingMessages: ChatMessage[];
   draft: string;
+  draftClientMessageId: string | null;
   replyToId: string | null;
   lastCursor: string | null;
   lastViewedMessageId: string | null;
+  notificationsEnabled: boolean;
+  unreadCount: number;
   wsConnection: ChatConnection | null;
   wsConnected: boolean;
   draftSyncTimer: ReturnType<typeof setTimeout> | null;
@@ -102,9 +116,12 @@ function createEmptyChannelState(): ChannelRuntimeState {
     messages: [],
     pendingMessages: [],
     draft: "",
+    draftClientMessageId: null,
     replyToId: null,
     lastCursor: null,
     lastViewedMessageId: null,
+    notificationsEnabled: false,
+    unreadCount: 0,
     wsConnection: null,
     wsConnected: false,
     draftSyncTimer: null,
@@ -152,6 +169,23 @@ function formatMentionToast(message: ChatMessage): string {
   return `@${author} mentioned you: ${snippet}`;
 }
 
+function formatReplyToast(message: ChatMessage): string {
+  const author = message.user.username || "Someone";
+  const normalized = message.content.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return `@${author} replied to you.`;
+  }
+  const snippet = normalized.length > 72 ? `${normalized.slice(0, 69)}...` : normalized;
+  return `@${author} replied to you: ${snippet}`;
+}
+
+function formatChannelToast(channelId: string, message: ChatMessage): string {
+  const author = message.user.username || "Someone";
+  const normalized = message.content.replace(/\s+/g, " ").trim();
+  const snippet = normalized.length > 72 ? `${normalized.slice(0, 69)}...` : normalized;
+  return snippet ? `#${channelId} @${author}: ${snippet}` : `#${channelId} @${author} sent a message.`;
+}
+
 function isLegacyTimestampCursor(cursor: string | null): boolean {
   return !!cursor && ISO_TIMESTAMP_CURSOR.test(cursor);
 }
@@ -171,6 +205,11 @@ function resolveHydratedCursor(messages: ChatMessage[], persistedCursor: string
   return persistedCursor === transcriptCursor ? persistedCursor : transcriptCursor;
 }
 
+function createClientMessageId(): string {
+  const randomUUID = globalThis.crypto?.randomUUID?.();
+  return randomUUID ?? `local:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+}
+
 function compareMessages(a: ChatMessage, b: ChatMessage): number {
   // Preserve server/insertion order inside same-timestamp batches so the bottom-most
   // rendered message stays the one selected first from the composer.
@@ -182,9 +221,11 @@ export class ChatController {
   private resume: PluginResumeState | null = null;
   private appActive = true;
   private hydrated = false;
+  private sessionToken: string | null = null;
   private sessionChecked = false;
   private user: { id: string; username: string; emailVerified: boolean } | null = null;
   private channels: ChatChannel[] = [];
+  private onlineCount = 0;
   private channelsLoading = false;
   private channelsPromise: Promise<void> | null = null;
   private channelStates = new Map<string, ChannelRuntimeState>();
@@ -193,6 +234,9 @@ export class ChatController {
   private pendingMessageSeq = 0;
   private notifyFn: (notification: AppNotificationRequest) => void = () => {};
   private listeners = new Set<ChannelListenerEntry>();
+  private chatNotificationUnsubscribe: (() => void) | null = null;
+  private chatPresenceUnsubscribe: (() => void) | null = null;
+  private notifiedMessageIds = new Set<string>();
 
   private get wsConnection(): ChatConnection | null {
     return this.ensureChannelState(DEFAULT_CHAT_CHANNEL_ID).wsConnection;
@@ -217,7 +261,8 @@ export class ChatController {
     }) ?? this.persistence.getState<PersistedSessionState>(SESSION_STATE_KEY, {
       schemaVersion: SESSION_SCHEMA_VERSION,
     });
-    apiClient.setSessionToken(session?.sessionToken ?? null);
+    this.sessionToken = session?.sessionToken ?? null;
+    apiClient.setSessionToken(this.sessionToken);
     // WebSocket tokens are short-lived connection credentials. Reusing a persisted
     // one can trap reconnects on an expired token even while the session cookie is valid.
     apiClient.setWebSocketToken(null);
@@ -259,11 +304,13 @@ export class ChatController {
     return {
       channelId: normalizedChannelId,
       channels: this.channels,
+      channelStates: this.getChannelStateSnapshots(),
       channelsLoading: this.channelsLoading,
       loading: !this.sessionChecked || channel.messagesLoading,
       loadingOlderMessages: channel.olderMessagesLoading,
       hasOlderMessages: channel.messages.length > 0 && !channel.reachedOldestMessage,
-      hasSavedSession: !!apiClient.getSessionToken(),
+      hasSavedSession: !!this.sessionToken,
+      onlineCount: this.onlineCount,
       user: this.user,
       messages: this.getVisibleMessages(normalizedChannelId),
       draft: channel.draft,
@@ -276,6 +323,22 @@ export class ChatController {
     return this.channels;
   }
 
+  private getChannelStateSnapshots(): ChatChannelState[] {
+    const channelIds = new Set<string>([
+      ...this.channels.map((channel) => channel.id),
+      ...this.channelStates.keys(),
+    ]);
+    return [...channelIds].map((channelId) => {
+      const channel = this.ensureChannelState(channelId);
+      return {
+        channelId,
+        notificationsEnabled: channel.notificationsEnabled,
+        lastReadMessageId: channel.lastViewedMessageId,
+        unreadCount: channel.unreadCount,
+      };
+    });
+  }
+
   async refreshChannels(): Promise<void> {
     if (this.channelsPromise) return this.channelsPromise;
     this.channelsLoading = true;
@@ -298,6 +361,33 @@ export class ChatController {
     return request;
   }
 
+  async refreshPresence(): Promise<void> {
+    const presence = await apiClient.getChatPresence();
+    this.onlineCount = presence.onlineCount;
+    this.emit();
+  }
+
+  async refreshChatState(): Promise<void> {
+    if (!this.user?.emailVerified || !this.sessionToken) {
+      await this.refreshPresence();
+      return;
+    }
+    const state = await apiClient.getChatState();
+    this.channels = normalizeChannels(state.channels);
+    this.onlineCount = state.onlineCount;
+    for (const entry of state.channelStates) {
+      const channel = this.ensureChannelState(entry.channelId);
+      channel.notificationsEnabled = entry.notificationsEnabled;
+      channel.unreadCount = entry.unreadCount;
+      channel.lastViewedMessageId = entry.lastReadMessageId ?? channel.lastViewedMessageId;
+    }
+    for (const notification of state.notifications) {
+      this.handleChatNotification(notification, { countUnread: false });
+    }
+    this.ensureOpenChannelConnections();
+    this.emit();
+  }
+
   async resolveRequiredChannelId(channelId: string): Promise<string> {
     const normalizedChannelId = normalizeChannelId(channelId);
     if (this.isKnownChannelId(normalizedChannelId)) {
@@ -350,6 +440,9 @@ export class ChatController {
       schemaVersion: CHANNEL_SCHEMA_VERSION,
     });
     channel.draft = persistedChannel?.draft ?? "";
+    channel.draftClientMessageId = channel.draft.trim()
+      ? persistedChannel?.draftClientMessageId ?? createClientMessageId()
+      : null;
     channel.replyToId = persistedChannel?.replyToId ?? null;
     const persistedCursor = persistedChannel?.lastCursor ?? null;
     const persistedViewedMessageId = persistedChannel?.lastViewedMessageId ?? null;
@@ -361,22 +454,26 @@ export class ChatController {
     });
     channel.messages = transcript?.value.messages ?? [];
     channel.lastCursor = resolveHydratedCursor(channel.messages, persistedCursor);
-    channel.lastViewedMessageId = this.user?.id && apiClient.getSessionToken()
+    channel.lastViewedMessageId = this.user?.id && this.sessionToken
       ? persistedViewedMessageId ?? getLatestMessageId(channel.messages)
       : null;
   }
 
   async refreshSession(): Promise<void> {
     const token = apiClient.getSessionToken();
+    this.sessionToken = token;
     if (!token) {
       this.stopVerificationPolling();
       this.stopSafetyRefresh();
+      this.stopRealtimeSubscriptions();
       this.closeAllConnections();
       this.user = null;
       this.sessionChecked = true;
       for (const channel of this.channelStates.values()) {
         channel.pendingMessages = [];
         channel.lastViewedMessageId = null;
+        channel.unreadCount = 0;
+        channel.notificationsEnabled = false;
       }
       this.persistSession();
       this.emit();
@@ -387,13 +484,17 @@ export class ChatController {
     if (!session) {
       this.stopVerificationPolling();
       this.stopSafetyRefresh();
+      this.stopRealtimeSubscriptions();
       this.closeAllConnections();
       apiClient.setSessionToken(null);
+      this.sessionToken = null;
       this.user = null;
       this.sessionChecked = true;
       for (const channel of this.channelStates.values()) {
         channel.pendingMessages = [];
         channel.lastViewedMessageId = null;
+        channel.unreadCount = 0;
+        channel.notificationsEnabled = false;
       }
       this.persistSession();
       this.emit();
@@ -402,6 +503,7 @@ export class ChatController {
 
     const previousIdentity = `${this.user?.id ?? ""}:${normalizeUsername(this.user?.username) ?? ""}`;
     const nextUser = { id: session.id, username: session.username ?? session.name, emailVerified: !!session.emailVerified };
+    this.sessionToken = apiClient.getSessionToken();
     this.user = nextUser;
     const nextIdentity = `${nextUser.id}:${normalizeUsername(nextUser.username) ?? ""}`;
     if (previousIdentity && previousIdentity !== nextIdentity) {
@@ -416,12 +518,15 @@ export class ChatController {
 
     if (nextUser?.emailVerified) {
       this.stopVerificationPolling();
+      this.ensureRealtimeSubscriptions();
+      await this.refreshChatState().catch(() => {});
       this.ensureOpenChannelConnections();
       return;
     }
 
     this.syncVerificationPolling();
     this.stopSafetyRefresh();
+    this.stopRealtimeSubscriptions();
     this.closeAllConnections();
   }
 
@@ -494,7 +599,13 @@ export class ChatController {
     const normalizedChannelId = normalizeChannelId(channelId);
     const channel = this.ensureChannelState(normalizedChannelId);
     if (draft === channel.draft) return;
+    const previousDraft = channel.draft;
     channel.draft = draft;
+    if (!draft.trim()) {
+      channel.draftClientMessageId = null;
+    } else if (!previousDraft.trim() || !channel.draftClientMessageId) {
+      channel.draftClientMessageId = createClientMessageId();
+    }
     this.scheduleDraftSync(normalizedChannelId);
   }
 
@@ -510,6 +621,33 @@ export class ChatController {
     this.emit(normalizedChannelId);
   }
 
+  setChannelNotificationsEnabled(channelId: string, enabled: boolean): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    if (channel.notificationsEnabled === enabled) return;
+
+    const previous = channel.notificationsEnabled;
+    channel.notificationsEnabled = enabled;
+    this.emit();
+    this.ensureOpenChannelConnections();
+
+    void apiClient.updateChatChannelState(normalizedChannelId, {
+      notificationsEnabled: enabled,
+    }).then((nextState) => {
+      this.applyChannelState(nextState);
+      this.ensureOpenChannelConnections();
+      this.emit();
+    }).catch((error) => {
+      channel.notificationsEnabled = previous;
+      this.ensureOpenChannelConnections();
+      this.emit();
+      this.notifyFn({
+        body: error instanceof Error ? error.message : "Failed to update channel notifications.",
+        type: "error",
+      });
+    });
+  }
+
   attachView(): () => void {
     return this.attachChannelView(DEFAULT_CHAT_CHANNEL_ID);
   }
@@ -530,12 +668,19 @@ export class ChatController {
   clearSession(): void {
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
+    this.stopRealtimeSubscriptions();
     this.closeAllConnections();
+    this.sessionToken = null;
     this.user = null;
     this.sessionChecked = false;
     for (const channel of this.channelStates.values()) {
       channel.pendingMessages = [];
+      channel.draftClientMessageId = channel.draft.trim()
+        ? createClientMessageId()
+        : null;
       channel.lastViewedMessageId = null;
+      channel.unreadCount = 0;
+      channel.notificationsEnabled = false;
     }
     this.emit();
   }
@@ -548,26 +693,32 @@ export class ChatController {
       return;
     }
     this.syncVerificationPolling();
+    void this.refreshChatState().catch(() => {});
   }
 
   reset(clearSession = false): void {
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
+    this.stopRealtimeSubscriptions();
     this.closeAllConnections();
     for (const [channelId, channel] of this.channelStates) {
       this.clearDraftSyncTimer(channel);
       channel.messages = [];
       channel.pendingMessages = [];
       channel.draft = "";
+      channel.draftClientMessageId = null;
       channel.replyToId = null;
       channel.lastCursor = null;
       channel.lastViewedMessageId = null;
+      channel.unreadCount = 0;
+      channel.notificationsEnabled = false;
       channel.reachedOldestMessage = false;
       channel.openViewCount = 0;
       this.persistence?.deleteResource(TRANSCRIPT_KIND, channelId, { sourceKey: TRANSCRIPT_SOURCE });
       this.persistChannelState(channelId);
     }
     if (clearSession) {
+      this.sessionToken = null;
       this.user = null;
       apiClient.setSessionToken(null);
       this.persistence?.deleteState(SESSION_STATE_KEY);
@@ -587,6 +738,7 @@ export class ChatController {
     }
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
+    this.stopRealtimeSubscriptions();
     this.closeAllConnections();
     for (const channel of this.channelStates.values()) {
       channel.messagesLoading = false;
@@ -597,33 +749,39 @@ export class ChatController {
     }
     this.notifyFn = () => {};
     this.listeners.clear();
+    this.notifiedMessageIds.clear();
   }
 
-  send(content: string, replyToId?: string): void {
-    this.sendToChannel(DEFAULT_CHAT_CHANNEL_ID, content, replyToId);
+  send(content: string, replyToId?: string): boolean {
+    return this.sendToChannel(DEFAULT_CHAT_CHANNEL_ID, content, replyToId);
   }
 
-  sendToChannel(channelId: string, content: string, replyToId?: string): void {
+  sendToChannel(channelId: string, content: string, replyToId?: string): boolean {
     const normalizedChannelId = normalizeChannelId(channelId);
     const channel = this.ensureChannelState(normalizedChannelId);
-    if (!this.user?.emailVerified || !apiClient.getSessionToken()) return;
-    if (!channel.wsConnection && this.user?.emailVerified && apiClient.getSessionToken()) {
+    const messageContent = content.trim();
+    if (!messageContent) return false;
+    if (!this.user?.emailVerified || !this.sessionToken) return false;
+    if (this.hasPendingSend(channel, messageContent, replyToId)) return true;
+    if (!channel.wsConnection && this.user?.emailVerified && this.sessionToken) {
       this.ensureConnection(normalizedChannelId);
     }
     const connection = channel.wsConnection;
     if (!connection) {
       this.notifyFn({ body: "Unable to send message right now.", type: "error" });
-      return;
+      return false;
     }
 
-    const pendingMessage = this.createPendingMessage(normalizedChannelId, content, replyToId);
+    const clientMessageId = channel.draftClientMessageId ?? createClientMessageId();
+    const pendingMessage = this.createPendingMessage(normalizedChannelId, messageContent, replyToId);
     channel.pendingMessages = [...channel.pendingMessages, pendingMessage];
     channel.draft = "";
+    channel.draftClientMessageId = null;
     channel.replyToId = null;
     this.persistChannelState(normalizedChannelId);
     this.emit(normalizedChannelId);
 
-    void connection.send(content, replyToId).then((message) => {
+    void connection.send(messageContent, replyToId, clientMessageId).then((message) => {
       channel.pendingMessages = channel.pendingMessages.filter((entry) => entry.id !== pendingMessage.id);
       this.mergeMessages(normalizedChannelId, [message]);
     }).catch((error) => {
@@ -636,12 +794,22 @@ export class ChatController {
       this.emit(normalizedChannelId);
       this.notifyFn({ body: errorMessage, type: "error" });
     });
+    return true;
+  }
+
+  private hasPendingSend(channel: ChannelRuntimeState, content: string, replyToId?: string): boolean {
+    const replyToKey = replyToId ?? null;
+    return channel.pendingMessages.some((message) => (
+      message.clientStatus === "sending"
+      && message.content === content
+      && message.replyToId === replyToKey
+    ));
   }
 
   ensureConnection(channelId = DEFAULT_CHAT_CHANNEL_ID): void {
     const normalizedChannelId = normalizeChannelId(channelId);
     const channel = this.ensureChannelState(normalizedChannelId);
-    if (!this.user?.emailVerified || !apiClient.getSessionToken()) {
+    if (!this.user?.emailVerified || !this.sessionToken) {
       this.stopSafetyRefresh();
       return;
     }
@@ -675,8 +843,15 @@ export class ChatController {
     }
   }
 
+  private applyChannelState(state: ChatChannelState): void {
+    const channel = this.ensureChannelState(state.channelId);
+    channel.notificationsEnabled = state.notificationsEnabled;
+    channel.unreadCount = state.unreadCount;
+    channel.lastViewedMessageId = state.lastReadMessageId ?? channel.lastViewedMessageId;
+  }
+
   private syncVerificationPolling(): void {
-    if (!this.appActive || !apiClient.getSessionToken() || !this.user || this.user.emailVerified) {
+    if (!this.appActive || !this.sessionToken || !this.user || this.user.emailVerified) {
       this.stopVerificationPolling();
       return;
     }
@@ -686,6 +861,27 @@ export class ChatController {
     }, VERIFICATION_POLL_MS);
   }
 
+  private ensureRealtimeSubscriptions(): void {
+    if (!this.chatNotificationUnsubscribe) {
+      this.chatNotificationUnsubscribe = apiClient.subscribeChatNotifications((notification) => {
+        this.handleChatNotification(notification);
+      });
+    }
+    if (!this.chatPresenceUnsubscribe) {
+      this.chatPresenceUnsubscribe = apiClient.subscribeChatPresence((onlineCount) => {
+        this.onlineCount = onlineCount;
+        this.emit();
+      });
+    }
+  }
+
+  private stopRealtimeSubscriptions(): void {
+    this.chatNotificationUnsubscribe?.();
+    this.chatNotificationUnsubscribe = null;
+    this.chatPresenceUnsubscribe?.();
+    this.chatPresenceUnsubscribe = null;
+  }
+
   private stopVerificationPolling(): void {
     if (!this.verificationPollTimer) return;
     clearInterval(this.verificationPollTimer);
@@ -695,7 +891,7 @@ export class ChatController {
   private startSafetyRefresh(): void {
     if (this.safetyRefreshTimer) return;
     this.safetyRefreshTimer = setInterval(() => {
-      if (!this.user?.emailVerified || !apiClient.getSessionToken()) {
+      if (!this.user?.emailVerified || !this.sessionToken) {
         this.stopSafetyRefresh();
         return;
       }
@@ -723,10 +919,16 @@ export class ChatController {
   private ensureOpenChannelConnections(): void {
     const channelIds = new Set<string>([DEFAULT_CHAT_CHANNEL_ID]);
     for (const [channelId, channel] of this.channelStates) {
-      if (channel.openViewCount > 0 || channel.wsConnection) {
+      if (channel.openViewCount > 0 || channel.notificationsEnabled) {
         channelIds.add(channelId);
       }
     }
+    for (const [channelId, channel] of this.channelStates) {
+      if (channelIds.has(channelId) || !channel.wsConnection || channel.openViewCount > 0) continue;
+      channel.wsConnection.close();
+      channel.wsConnection = null;
+      channel.wsConnected = false;
+    }
     for (const channelId of channelIds) {
       this.ensureConnection(channelId);
     }
@@ -734,7 +936,7 @@ export class ChatController {
 
   private getSafetyRefreshChannelIds(): string[] {
     const active = [...this.channelStates.entries()]
-      .filter(([, channel]) => channel.openViewCount > 0 || channel.wsConnection)
+      .filter(([, channel]) => channel.openViewCount > 0 || channel.notificationsEnabled || channel.wsConnection)
       .map(([channelId]) => channelId);
     return active.length > 0 ? active : [DEFAULT_CHAT_CHANNEL_ID];
   }
@@ -743,6 +945,8 @@ export class ChatController {
     const channel = this.ensureChannelState(channelId);
     const legacyTimestampCursor = isLegacyTimestampCursor(channel.lastCursor);
     const hasIncrementalCursor = !!channel.lastCursor;
+    const hadMessages = channel.messages.length > 0;
+    const countIncrementalUnread = hadMessages && hasIncrementalCursor && !legacyTimestampCursor;
 
     try {
       const messages = await apiClient.getMessages(channelId, {
@@ -753,7 +957,7 @@ export class ChatController {
         channel.reachedOldestMessage = true;
       }
       if (messages.length > 0) {
-        this.mergeMessages(channelId, messages);
+        this.mergeMessages(channelId, messages, { countUnread: countIncrementalUnread });
         return;
       }
       if (legacyTimestampCursor) {
@@ -762,7 +966,7 @@ export class ChatController {
           channel.reachedOldestMessage = true;
         }
         if (fullRefresh.length > 0) {
-          this.mergeMessages(channelId, fullRefresh);
+          this.mergeMessages(channelId, fullRefresh, { countUnread: false });
           return;
         }
         channel.lastCursor = null;
@@ -775,7 +979,7 @@ export class ChatController {
         channel.reachedOldestMessage = true;
       }
       if (messages.length > 0) {
-        this.mergeMessages(channelId, messages);
+        this.mergeMessages(channelId, messages, { countUnread: false });
         return;
       }
       this.persistChannelState(channelId);
@@ -795,20 +999,20 @@ export class ChatController {
       this.persistChannelState(channelId);
       return;
     }
-    this.mergeMessages(channelId, messages, { notifyMentions: false });
+    this.mergeMessages(channelId, messages, { countUnread: false });
   }
 
   private mergeMessages(
     channelIdOrMessages: string | ChatMessage[],
-    maybeMessages?: ChatMessage[] | { notifyMentions?: boolean },
-    maybeOptions?: { notifyMentions?: boolean },
+    maybeMessages?: ChatMessage[] | MergeMessagesOptions,
+    maybeOptions?: MergeMessagesOptions,
   ): void {
     const channelId = Array.isArray(channelIdOrMessages) ? DEFAULT_CHAT_CHANNEL_ID : channelIdOrMessages;
     const messages = Array.isArray(channelIdOrMessages)
       ? channelIdOrMessages
       : (maybeMessages as ChatMessage[] | undefined) ?? [];
     const options = Array.isArray(channelIdOrMessages)
-      ? maybeMessages as { notifyMentions?: boolean } | undefined
+      ? maybeMessages as MergeMessagesOptions | undefined
       : maybeOptions;
     const channel = this.ensureChannelState(channelId);
     this.reconcilePendingMessages(channelId, messages);
@@ -824,11 +1028,11 @@ export class ChatController {
     channel.messages = [...merged.values()]
       .sort(compareMessages);
     channel.lastCursor = channel.messages[channel.messages.length - 1]?.id ?? channel.lastCursor;
+    const freshIncoming = [...incoming.values()].filter((message) => message.user.id !== this.user?.id);
     if (channel.openViewCount > 0) {
       this.markViewedThroughLatestMessage(channelId, false);
-    }
-    if (options?.notifyMentions !== false) {
-      this.trackUnreadMentions(channelId, [...incoming.values()]);
+    } else if (freshIncoming.length > 0 && options?.countUnread !== false) {
+      channel.unreadCount += freshIncoming.length;
     }
     this.persistTranscript(channelId);
     this.emit(channelId);
@@ -836,7 +1040,7 @@ export class ChatController {
 
   private persistSession(): void {
     const value = {
-      sessionToken: apiClient.getSessionToken(),
+      sessionToken: this.sessionToken,
       user: this.user,
     } satisfies PersistedSessionState;
     this.resume?.setState(SESSION_STATE_KEY, value, {
@@ -857,6 +1061,7 @@ export class ChatController {
     const channel = this.ensureChannelState(channelId);
     const value = {
       draft: channel.draft,
+      draftClientMessageId: channel.draftClientMessageId,
       replyToId: channel.replyToId,
       lastCursor: channel.lastCursor,
       lastViewedMessageId: channel.lastViewedMessageId,
@@ -911,27 +1116,27 @@ export class ChatController {
     this.persistChannelState(channelId);
   }
 
-  private trackUnreadMentions(channelId: string, messages: ChatMessage[]): void {
-    const channel = this.ensureChannelState(channelId);
-    if (channel.openViewCount > 0) {
-      return;
+  private handleChatNotification(notification: ChatNotification, options: { countUnread?: boolean } = {}): void {
+    this.mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
+    const channel = this.ensureChannelState(notification.channelId);
+    if (channel.openViewCount === 0) {
+      this.notifyServerMessage(notification);
     }
+    void apiClient.markChatNotificationsDelivered([notification.id]).catch(() => {});
+  }
 
-    const freshMentions = this.getMentionMessages(messages);
-    if (freshMentions.length === 0) return;
-
-    if (freshMentions.length === 1) {
-      this.notifyFn({
-        title: "Gloomberb chat",
-        body: formatMentionToast(freshMentions[0]!),
-        type: "info",
-        desktop: "when-inactive",
-      });
-      return;
-    }
+  private notifyServerMessage(notification: ChatNotification): void {
+    if (this.notifiedMessageIds.has(notification.messageId)) return;
+    this.notifiedMessageIds.add(notification.messageId);
+    const body = notification.type === "reply"
+      ? formatReplyToast(notification.message)
+      : notification.type === "mention"
+        ? formatMentionToast(notification.message)
+        : formatChannelToast(notification.channelId, notification.message);
     this.notifyFn({
       title: "Gloomberb chat",
-      body: `${freshMentions.length} new mentions in #${channelId}.`,
+      subtitle: `#${notification.channelId}`,
+      body,
       type: "info",
       desktop: "when-inactive",
     });
@@ -966,13 +1171,23 @@ export class ChatController {
   private markViewedThroughLatestMessage(channelId: string, persist = true): boolean {
     const channel = this.ensureChannelState(channelId);
     const latestMessageId = channel.messages[channel.messages.length - 1]?.id ?? null;
-    if (channel.lastViewedMessageId === latestMessageId) {
+    const previousUnreadCount = channel.unreadCount;
+    if (channel.lastViewedMessageId === latestMessageId && previousUnreadCount === 0) {
       return false;
     }
     channel.lastViewedMessageId = latestMessageId;
+    channel.unreadCount = 0;
     if (persist) {
       this.persistChannelState(channelId);
     }
+    if (latestMessageId && this.user?.emailVerified && this.sessionToken) {
+      void apiClient.updateChatChannelState(channelId, {
+        readThroughMessageId: latestMessageId,
+      }).then((state) => {
+        this.applyChannelState(state);
+        this.emit();
+      }).catch(() => {});
+    }
     return true;
   }
 
@@ -1001,7 +1216,7 @@ export class ChatController {
       replyTo: replyToMessage
         ? {
           content: replyToMessage.content,
-          user: { username: replyToMessage.user.username },
+          user: { id: replyToMessage.user.id, username: replyToMessage.user.username },
         }
         : null,
       clientStatus: "sending",