gloomberb 0.7.0 → 0.7.2

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

@@ -1,10 +1,10 @@
 import type { AppNotificationRequest, PluginPersistence, PluginResumeState } from "../../types/plugin";
-import { apiClient, type ChatMessage, type PersistedAuthUser } from "../../utils/api-client";
+import { apiClient, type ChatChannel, type ChatMessage, type PersistedAuthUser } from "../../utils/api-client";
 import { debugLog } from "../../utils/debug-log";
 import { toTimestampMillis } from "../../utils/timestamp";
 
 const SESSION_STATE_KEY = "session";
-const CHANNEL_STATE_KEY = "channel:everyone";
+const DEFAULT_CHAT_CHANNEL_ID = "everyone";
 const TRANSCRIPT_KIND = "channel-transcript";
 const TRANSCRIPT_SOURCE = "server";
 const MESSAGE_PAGE_SIZE = 50;
@@ -42,6 +42,9 @@ interface PersistedTranscript {
 }
 
 export interface ChatControllerSnapshot {
+  channelId: string;
+  channels: ChatChannel[];
+  channelsLoading: boolean;
   loading: boolean;
   loadingOlderMessages: boolean;
   hasOlderMessages: boolean;
@@ -55,6 +58,74 @@ export interface ChatControllerSnapshot {
 
 type ChatConnection = { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void };
 
+interface ChannelRuntimeState {
+  hydrated: boolean;
+  messagesLoading: boolean;
+  olderMessagesLoading: boolean;
+  refreshMessagesPromise: Promise<void> | null;
+  loadOlderMessagesPromise: Promise<void> | null;
+  reachedOldestMessage: boolean;
+  messages: ChatMessage[];
+  pendingMessages: ChatMessage[];
+  draft: string;
+  replyToId: string | null;
+  lastCursor: string | null;
+  lastViewedMessageId: string | null;
+  wsConnection: ChatConnection | null;
+  wsConnected: boolean;
+  draftSyncTimer: ReturnType<typeof setTimeout> | null;
+  openViewCount: number;
+}
+
+interface ChannelListenerEntry {
+  channelId: string;
+  listener: (snapshot: ChatControllerSnapshot) => void;
+}
+
+function channelStateKey(channelId: string): string {
+  return `channel:${channelId}`;
+}
+
+function normalizeChannelId(channelId: string | null | undefined): string {
+  const normalized = channelId?.trim();
+  return normalized || DEFAULT_CHAT_CHANNEL_ID;
+}
+
+function createEmptyChannelState(): ChannelRuntimeState {
+  return {
+    hydrated: false,
+    messagesLoading: false,
+    olderMessagesLoading: false,
+    refreshMessagesPromise: null,
+    loadOlderMessagesPromise: null,
+    reachedOldestMessage: false,
+    messages: [],
+    pendingMessages: [],
+    draft: "",
+    replyToId: null,
+    lastCursor: null,
+    lastViewedMessageId: null,
+    wsConnection: null,
+    wsConnected: false,
+    draftSyncTimer: null,
+    openViewCount: 0,
+  };
+}
+
+function normalizeChannels(channels: ChatChannel[]): ChatChannel[] {
+  const byId = new Map<string, ChatChannel>();
+  for (const channel of channels) {
+    const id = channel.id.trim();
+    if (!id) continue;
+    byId.set(id, {
+      ...channel,
+      id,
+      name: channel.name.trim() || id,
+    });
+  }
+  return [...byId.values()];
+}
+
 function normalizeUsername(username: string | null | undefined): string | null {
   const trimmed = username?.trim();
   return trimmed ? trimmed.toLowerCase() : null;
@@ -112,27 +183,20 @@ export class ChatController {
   private appActive = true;
   private hydrated = false;
   private sessionChecked = false;
-  private messagesLoading = false;
-  private olderMessagesLoading = false;
-  private refreshMessagesPromise: Promise<void> | null = null;
-  private loadOlderMessagesPromise: Promise<void> | null = null;
-  private reachedOldestMessage = false;
   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 channels: ChatChannel[] = [];
+  private channelsLoading = false;
+  private channelsPromise: Promise<void> | null = null;
+  private channelStates = new Map<string, ChannelRuntimeState>();
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
   private safetyRefreshTimer: ReturnType<typeof setInterval> | null = null;
-  private draftSyncTimer: ReturnType<typeof setTimeout> | null = null;
-  private openViewCount = 0;
   private pendingMessageSeq = 0;
   private notifyFn: (notification: AppNotificationRequest) => void = () => {};
-  private listeners = new Set<(snapshot: ChatControllerSnapshot) => void>();
+  private listeners = new Set<ChannelListenerEntry>();
+
+  private get wsConnection(): ChatConnection | null {
+    return this.ensureChannelState(DEFAULT_CHAT_CHANNEL_ID).wsConnection;
+  }
 
   attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
     this.persistence = persistence;
@@ -166,64 +230,154 @@ export class ChatController {
       }
       : null;
     this.sessionChecked = true;
-
-    const channel = this.resume?.getState<PersistedChannelState>(CHANNEL_STATE_KEY, {
-      schemaVersion: CHANNEL_SCHEMA_VERSION,
-    }) ?? this.persistence.getState<PersistedChannelState>(CHANNEL_STATE_KEY, {
-      schemaVersion: CHANNEL_SCHEMA_VERSION,
-    });
-    this.draft = channel?.draft ?? "";
-    this.replyToId = channel?.replyToId ?? null;
-    const persistedCursor = channel?.lastCursor ?? null;
-    const persistedViewedMessageId = channel?.lastViewedMessageId ?? null;
-
-    const transcript = this.persistence.getResource<PersistedTranscript>(TRANSCRIPT_KIND, "everyone", {
-      sourceKey: TRANSCRIPT_SOURCE,
-      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
-      allowExpired: true,
-    });
-    this.messages = transcript?.value.messages ?? [];
-    this.lastCursor = resolveHydratedCursor(this.messages, persistedCursor);
-    this.lastViewedMessageId = this.user?.id && apiClient.getSessionToken()
-      ? persistedViewedMessageId ?? getLatestMessageId(this.messages)
-      : null;
+    this.ensureChannelState(DEFAULT_CHAT_CHANNEL_ID);
     this.syncVerificationPolling();
   }
 
-  subscribe(listener: (snapshot: ChatControllerSnapshot) => void): () => void {
-    this.listeners.add(listener);
-    listener(this.getSnapshot());
+  subscribe(listener: (snapshot: ChatControllerSnapshot) => void): () => void;
+  subscribe(channelId: string, listener: (snapshot: ChatControllerSnapshot) => void): () => void;
+  subscribe(
+    channelIdOrListener: string | ((snapshot: ChatControllerSnapshot) => void),
+    maybeListener?: (snapshot: ChatControllerSnapshot) => void,
+  ): () => void {
+    const channelId = typeof channelIdOrListener === "string"
+      ? normalizeChannelId(channelIdOrListener)
+      : DEFAULT_CHAT_CHANNEL_ID;
+    const listener = typeof channelIdOrListener === "function" ? channelIdOrListener : maybeListener;
+    if (!listener) return () => {};
+    const entry = { channelId, listener };
+    this.listeners.add(entry);
+    listener(this.getSnapshot(channelId));
     return () => {
-      this.listeners.delete(listener);
+      this.listeners.delete(entry);
     };
   }
 
-  getSnapshot(): ChatControllerSnapshot {
+  getSnapshot(channelId = DEFAULT_CHAT_CHANNEL_ID): ChatControllerSnapshot {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
     return {
-      loading: !this.sessionChecked || this.messagesLoading,
-      loadingOlderMessages: this.olderMessagesLoading,
-      hasOlderMessages: this.messages.length > 0 && !this.reachedOldestMessage,
+      channelId: normalizedChannelId,
+      channels: this.channels,
+      channelsLoading: this.channelsLoading,
+      loading: !this.sessionChecked || channel.messagesLoading,
+      loadingOlderMessages: channel.olderMessagesLoading,
+      hasOlderMessages: channel.messages.length > 0 && !channel.reachedOldestMessage,
       hasSavedSession: !!apiClient.getSessionToken(),
       user: this.user,
-      messages: this.getVisibleMessages(),
-      draft: this.draft,
-      replyToId: this.replyToId,
-      unreadMentionCount: this.getUnreadMentionCount(),
+      messages: this.getVisibleMessages(normalizedChannelId),
+      draft: channel.draft,
+      replyToId: channel.replyToId,
+      unreadMentionCount: this.getUnreadMentionCount(normalizedChannelId),
     };
   }
 
+  getChannels(): ChatChannel[] {
+    return this.channels;
+  }
+
+  async refreshChannels(): Promise<void> {
+    if (this.channelsPromise) return this.channelsPromise;
+    this.channelsLoading = true;
+    this.emit();
+
+    const request = apiClient.getChannels()
+      .then((channels) => {
+        this.channels = normalizeChannels(channels);
+      })
+      .catch(() => {
+        // Keep the last backend-provided list if the refresh fails.
+      })
+      .finally(() => {
+        this.channelsLoading = false;
+        this.channelsPromise = null;
+        this.emit();
+      });
+
+    this.channelsPromise = request;
+    return request;
+  }
+
+  async resolveRequiredChannelId(channelId: string): Promise<string> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    if (this.isKnownChannelId(normalizedChannelId)) {
+      return normalizedChannelId;
+    }
+    await this.refreshChannels();
+    if (this.isKnownChannelId(normalizedChannelId)) {
+      return normalizedChannelId;
+    }
+    throw new Error(`Unknown chat channel "#${normalizedChannelId}".`);
+  }
+
+  async resolvePreferredChannelId(channelId: string | null | undefined): Promise<string> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    if (this.isKnownChannelId(normalizedChannelId)) {
+      return normalizedChannelId;
+    }
+    await this.refreshChannels();
+    if (this.isKnownChannelId(normalizedChannelId)) {
+      return normalizedChannelId;
+    }
+    if (this.isKnownChannelId(DEFAULT_CHAT_CHANNEL_ID)) {
+      return DEFAULT_CHAT_CHANNEL_ID;
+    }
+    return this.channels[0]?.id ?? DEFAULT_CHAT_CHANNEL_ID;
+  }
+
+  private isKnownChannelId(channelId: string): boolean {
+    return this.channels.some((channel) => channel.id === channelId);
+  }
+
+  private ensureChannelState(channelId: string): ChannelRuntimeState {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const existing = this.channelStates.get(normalizedChannelId);
+    if (existing) return existing;
+
+    const channel = createEmptyChannelState();
+    this.channelStates.set(normalizedChannelId, channel);
+    this.hydrateChannelState(normalizedChannelId, channel);
+    return channel;
+  }
+
+  private hydrateChannelState(channelId: string, channel: ChannelRuntimeState): void {
+    if (channel.hydrated || !this.persistence) return;
+    channel.hydrated = true;
+
+    const persistedChannel = this.resume?.getState<PersistedChannelState>(channelStateKey(channelId), {
+      schemaVersion: CHANNEL_SCHEMA_VERSION,
+    }) ?? this.persistence.getState<PersistedChannelState>(channelStateKey(channelId), {
+      schemaVersion: CHANNEL_SCHEMA_VERSION,
+    });
+    channel.draft = persistedChannel?.draft ?? "";
+    channel.replyToId = persistedChannel?.replyToId ?? null;
+    const persistedCursor = persistedChannel?.lastCursor ?? null;
+    const persistedViewedMessageId = persistedChannel?.lastViewedMessageId ?? null;
+
+    const transcript = this.persistence.getResource<PersistedTranscript>(TRANSCRIPT_KIND, channelId, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      allowExpired: true,
+    });
+    channel.messages = transcript?.value.messages ?? [];
+    channel.lastCursor = resolveHydratedCursor(channel.messages, persistedCursor);
+    channel.lastViewedMessageId = this.user?.id && apiClient.getSessionToken()
+      ? persistedViewedMessageId ?? getLatestMessageId(channel.messages)
+      : null;
+  }
+
   async refreshSession(): Promise<void> {
     const token = apiClient.getSessionToken();
     if (!token) {
       this.stopVerificationPolling();
       this.stopSafetyRefresh();
-      this.wsConnection?.close();
-      this.wsConnection = null;
-      this.wsConnected = false;
+      this.closeAllConnections();
       this.user = null;
       this.sessionChecked = true;
-      this.pendingMessages = [];
-      this.lastViewedMessageId = null;
+      for (const channel of this.channelStates.values()) {
+        channel.pendingMessages = [];
+        channel.lastViewedMessageId = null;
+      }
       this.persistSession();
       this.emit();
       return;
@@ -233,14 +387,14 @@ export class ChatController {
     if (!session) {
       this.stopVerificationPolling();
       this.stopSafetyRefresh();
-      this.wsConnection?.close();
-      this.wsConnection = null;
-      this.wsConnected = false;
+      this.closeAllConnections();
       apiClient.setSessionToken(null);
       this.user = null;
       this.sessionChecked = true;
-      this.pendingMessages = [];
-      this.lastViewedMessageId = null;
+      for (const channel of this.channelStates.values()) {
+        channel.pendingMessages = [];
+        channel.lastViewedMessageId = null;
+      }
       this.persistSession();
       this.emit();
       return;
@@ -251,8 +405,10 @@ export class ChatController {
     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();
+      for (const [channelId, channel] of this.channelStates) {
+        channel.lastViewedMessageId = channel.messages[channel.messages.length - 1]?.id ?? null;
+        this.persistChannelState(channelId);
+      }
     }
     this.sessionChecked = true;
     this.persistSession();
@@ -260,100 +416,127 @@ export class ChatController {
 
     if (nextUser?.emailVerified) {
       this.stopVerificationPolling();
-      this.ensureConnection();
+      this.ensureOpenChannelConnections();
       return;
     }
 
     this.syncVerificationPolling();
     this.stopSafetyRefresh();
-    this.wsConnection?.close();
-    this.wsConnection = null;
-    this.wsConnected = false;
+    this.closeAllConnections();
   }
 
   async refreshMessages(): Promise<void> {
-    return this.runMessagesRefresh({ showLoading: true });
+    return this.refreshChannelMessages(DEFAULT_CHAT_CHANNEL_ID);
   }
 
-  private async runMessagesRefresh(options: { showLoading: boolean }): Promise<void> {
-    if (this.refreshMessagesPromise) return this.refreshMessagesPromise;
+  async refreshChannelMessages(channelId: string): Promise<void> {
+    return this.runMessagesRefresh(normalizeChannelId(channelId), { showLoading: true });
+  }
+
+  private async runMessagesRefresh(channelId: string, options: { showLoading: boolean }): Promise<void> {
+    const channel = this.ensureChannelState(channelId);
+    if (channel.refreshMessagesPromise) return channel.refreshMessagesPromise;
 
     if (options.showLoading) {
-      this.messagesLoading = true;
-      this.emit();
+      channel.messagesLoading = true;
+      this.emit(channelId);
     }
 
-    const request = this.fetchMessages()
+    const request = this.fetchMessages(channelId)
       .catch(() => {
-        this.persistChannelState();
+        this.persistChannelState(channelId);
       })
       .finally(() => {
         if (options.showLoading) {
-          this.messagesLoading = false;
+          channel.messagesLoading = false;
         }
-        this.refreshMessagesPromise = null;
-        this.emit();
+        channel.refreshMessagesPromise = null;
+        this.emit(channelId);
       });
 
-    this.refreshMessagesPromise = request;
+    channel.refreshMessagesPromise = request;
     return request;
   }
 
   async loadOlderMessages(): Promise<void> {
-    if (this.loadOlderMessagesPromise) return this.loadOlderMessagesPromise;
-    const before = this.messages[0]?.id ?? null;
-    if (!before || this.reachedOldestMessage) return;
+    return this.loadOlderChannelMessages(DEFAULT_CHAT_CHANNEL_ID);
+  }
 
-    this.olderMessagesLoading = true;
-    this.emit();
+  async loadOlderChannelMessages(channelId: string): Promise<void> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    if (channel.loadOlderMessagesPromise) return channel.loadOlderMessagesPromise;
+    const before = channel.messages[0]?.id ?? null;
+    if (!before || channel.reachedOldestMessage) return;
+
+    channel.olderMessagesLoading = true;
+    this.emit(normalizedChannelId);
 
-    const request = this.fetchOlderMessages(before)
+    const request = this.fetchOlderMessages(normalizedChannelId, before)
       .catch(() => {
-        this.persistChannelState();
+        this.persistChannelState(normalizedChannelId);
       })
       .finally(() => {
-        this.olderMessagesLoading = false;
-        this.loadOlderMessagesPromise = null;
-        this.emit();
+        channel.olderMessagesLoading = false;
+        channel.loadOlderMessagesPromise = null;
+        this.emit(normalizedChannelId);
       });
 
-    this.loadOlderMessagesPromise = request;
+    channel.loadOlderMessagesPromise = request;
     return request;
   }
 
   setDraft(draft: string): void {
-    if (draft === this.draft) return;
-    this.draft = draft;
-    this.scheduleDraftSync();
+    this.setChannelDraft(DEFAULT_CHAT_CHANNEL_ID, draft);
+  }
+
+  setChannelDraft(channelId: string, draft: string): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    if (draft === channel.draft) return;
+    channel.draft = draft;
+    this.scheduleDraftSync(normalizedChannelId);
   }
 
   setReplyToId(replyToId: string | null): void {
-    this.replyToId = replyToId;
-    this.persistChannelState();
-    this.emit();
+    this.setChannelReplyToId(DEFAULT_CHAT_CHANNEL_ID, replyToId);
+  }
+
+  setChannelReplyToId(channelId: string, replyToId: string | null): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    channel.replyToId = replyToId;
+    this.persistChannelState(normalizedChannelId);
+    this.emit(normalizedChannelId);
   }
 
   attachView(): () => void {
-    this.openViewCount += 1;
-    if (this.markViewedThroughLatestMessage()) {
-      this.emit();
+    return this.attachChannelView(DEFAULT_CHAT_CHANNEL_ID);
+  }
+
+  attachChannelView(channelId: string): () => void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    channel.openViewCount += 1;
+    if (this.markViewedThroughLatestMessage(normalizedChannelId)) {
+      this.emit(normalizedChannelId);
     }
     return () => {
-      this.openViewCount = Math.max(0, this.openViewCount - 1);
-      this.flushDraftSync();
+      channel.openViewCount = Math.max(0, channel.openViewCount - 1);
+      this.flushDraftSync(normalizedChannelId);
     };
   }
 
   clearSession(): void {
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
-    this.wsConnection?.close();
-    this.wsConnection = null;
-    this.wsConnected = false;
+    this.closeAllConnections();
     this.user = null;
     this.sessionChecked = false;
-    this.pendingMessages = [];
-    this.lastViewedMessageId = null;
+    for (const channel of this.channelStates.values()) {
+      channel.pendingMessages = [];
+      channel.lastViewedMessageId = null;
+    }
     this.emit();
   }
 
@@ -370,17 +553,20 @@ export class ChatController {
   reset(clearSession = false): void {
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
-    this.wsConnection?.close();
-    this.wsConnection = null;
-    this.wsConnected = false;
-    this.messages = [];
-    this.pendingMessages = [];
-    this.draft = "";
-    this.replyToId = null;
-    this.lastCursor = null;
-    this.lastViewedMessageId = null;
-    this.reachedOldestMessage = false;
-    this.openViewCount = 0;
+    this.closeAllConnections();
+    for (const [channelId, channel] of this.channelStates) {
+      this.clearDraftSyncTimer(channel);
+      channel.messages = [];
+      channel.pendingMessages = [];
+      channel.draft = "";
+      channel.replyToId = null;
+      channel.lastCursor = null;
+      channel.lastViewedMessageId = null;
+      channel.reachedOldestMessage = false;
+      channel.openViewCount = 0;
+      this.persistence?.deleteResource(TRANSCRIPT_KIND, channelId, { sourceKey: TRANSCRIPT_SOURCE });
+      this.persistChannelState(channelId);
+    }
     if (clearSession) {
       this.user = null;
       apiClient.setSessionToken(null);
@@ -388,92 +574,101 @@ export class ChatController {
     } else {
       this.persistSession();
     }
-    this.persistence?.deleteResource(TRANSCRIPT_KIND, "everyone", { sourceKey: TRANSCRIPT_SOURCE });
-    this.persistChannelState();
     this.emit();
   }
 
   dispose(): void {
     chatLog.info("dispose controller", {
       listeners: this.listeners.size,
-      hasConnection: !!this.wsConnection,
+      connections: [...this.channelStates.values()].filter((channel) => !!channel.wsConnection).length,
     });
-    this.flushDraftSync();
+    for (const [channelId] of this.channelStates) {
+      this.flushDraftSync(channelId);
+    }
     this.stopVerificationPolling();
     this.stopSafetyRefresh();
-    this.wsConnection?.close();
-    this.wsConnection = null;
-    this.wsConnected = false;
-    this.messagesLoading = false;
-    this.olderMessagesLoading = false;
-    this.refreshMessagesPromise = null;
-    this.loadOlderMessagesPromise = null;
-    this.openViewCount = 0;
+    this.closeAllConnections();
+    for (const channel of this.channelStates.values()) {
+      channel.messagesLoading = false;
+      channel.olderMessagesLoading = false;
+      channel.refreshMessagesPromise = null;
+      channel.loadOlderMessagesPromise = null;
+      channel.openViewCount = 0;
+    }
     this.notifyFn = () => {};
     this.listeners.clear();
   }
 
   send(content: string, replyToId?: string): void {
+    this.sendToChannel(DEFAULT_CHAT_CHANNEL_ID, content, replyToId);
+  }
+
+  sendToChannel(channelId: string, content: string, replyToId?: string): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
     if (!this.user?.emailVerified || !apiClient.getSessionToken()) return;
-    if (!this.wsConnection && this.user?.emailVerified && apiClient.getSessionToken()) {
-      this.ensureConnection();
+    if (!channel.wsConnection && this.user?.emailVerified && apiClient.getSessionToken()) {
+      this.ensureConnection(normalizedChannelId);
     }
-    const connection = this.wsConnection;
+    const connection = channel.wsConnection;
     if (!connection) {
       this.notifyFn({ body: "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();
+    const pendingMessage = this.createPendingMessage(normalizedChannelId, content, replyToId);
+    channel.pendingMessages = [...channel.pendingMessages, pendingMessage];
+    channel.draft = "";
+    channel.replyToId = null;
+    this.persistChannelState(normalizedChannelId);
+    this.emit(normalizedChannelId);
 
     void connection.send(content, replyToId).then((message) => {
-      this.pendingMessages = this.pendingMessages.filter((entry) => entry.id !== pendingMessage.id);
-      this.mergeMessages([message]);
+      channel.pendingMessages = channel.pendingMessages.filter((entry) => entry.id !== pendingMessage.id);
+      this.mergeMessages(normalizedChannelId, [message]);
     }).catch((error) => {
       const errorMessage = error instanceof Error && error.message ? error.message : "Failed to send message.";
-      this.pendingMessages = this.pendingMessages.map((entry) => (
+      channel.pendingMessages = channel.pendingMessages.map((entry) => (
         entry.id === pendingMessage.id
           ? { ...entry, clientStatus: "failed", clientError: errorMessage }
           : entry
       ));
-      this.emit();
+      this.emit(normalizedChannelId);
       this.notifyFn({ body: errorMessage, type: "error" });
     });
   }
 
-  ensureConnection(): void {
+  ensureConnection(channelId = DEFAULT_CHAT_CHANNEL_ID): void {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
     if (!this.user?.emailVerified || !apiClient.getSessionToken()) {
       this.stopSafetyRefresh();
       return;
     }
     this.startSafetyRefresh();
-    if (this.wsConnected) return;
-    this.wsConnected = true;
+    if (channel.wsConnected) return;
+    channel.wsConnected = true;
 
-    void this.refreshMessages().catch(() => {});
+    void this.refreshChannelMessages(normalizedChannelId).catch(() => {});
 
-    this.wsConnection = apiClient.connectChannel(
-      "everyone",
+    channel.wsConnection = apiClient.connectChannel(
+      normalizedChannelId,
       (message) => {
-        if (this.messages.some((entry) => entry.id === message.id)) return;
-        this.mergeMessages([message]);
+        if (channel.messages.some((entry) => entry.id === message.id)) return;
+        this.mergeMessages(normalizedChannelId, [message]);
       },
       () => {
-        this.wsConnected = false;
+        channel.wsConnected = false;
       },
     );
   }
 
-  private emit(): void {
-    const snapshot = this.getSnapshot();
-    for (const listener of this.listeners) {
+  private emit(channelId?: string): void {
+    for (const entry of this.listeners) {
+      if (channelId && entry.channelId !== channelId) continue;
+      const snapshot = this.getSnapshot(entry.channelId);
       try {
-        listener(snapshot);
+        entry.listener(snapshot);
       } catch {
         // ignore subscriber errors
       }
@@ -504,7 +699,9 @@ export class ChatController {
         this.stopSafetyRefresh();
         return;
       }
-      void this.runMessagesRefresh({ showLoading: false }).catch(() => {});
+      for (const channelId of this.getSafetyRefreshChannelIds()) {
+        void this.runMessagesRefresh(channelId, { showLoading: false }).catch(() => {});
+      }
     }, SAFETY_REFRESH_MS);
     this.safetyRefreshTimer.unref?.();
   }
@@ -515,85 +712,126 @@ export class ChatController {
     this.safetyRefreshTimer = null;
   }
 
-  private async fetchMessages(): Promise<void> {
-    const legacyTimestampCursor = isLegacyTimestampCursor(this.lastCursor);
-    const hasIncrementalCursor = !!this.lastCursor;
+  private closeAllConnections(): void {
+    for (const channel of this.channelStates.values()) {
+      channel.wsConnection?.close();
+      channel.wsConnection = null;
+      channel.wsConnected = false;
+    }
+  }
+
+  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) {
+        channelIds.add(channelId);
+      }
+    }
+    for (const channelId of channelIds) {
+      this.ensureConnection(channelId);
+    }
+  }
+
+  private getSafetyRefreshChannelIds(): string[] {
+    const active = [...this.channelStates.entries()]
+      .filter(([, channel]) => channel.openViewCount > 0 || channel.wsConnection)
+      .map(([channelId]) => channelId);
+    return active.length > 0 ? active : [DEFAULT_CHAT_CHANNEL_ID];
+  }
+
+  private async fetchMessages(channelId: string): Promise<void> {
+    const channel = this.ensureChannelState(channelId);
+    const legacyTimestampCursor = isLegacyTimestampCursor(channel.lastCursor);
+    const hasIncrementalCursor = !!channel.lastCursor;
 
     try {
-      const messages = await apiClient.getMessages("everyone", {
+      const messages = await apiClient.getMessages(channelId, {
         limit: MESSAGE_PAGE_SIZE,
-        after: this.lastCursor ?? undefined,
+        after: channel.lastCursor ?? undefined,
       });
       if (!hasIncrementalCursor && messages.length < MESSAGE_PAGE_SIZE) {
-        this.reachedOldestMessage = true;
+        channel.reachedOldestMessage = true;
       }
       if (messages.length > 0) {
-        this.mergeMessages(messages);
+        this.mergeMessages(channelId, messages);
         return;
       }
       if (legacyTimestampCursor) {
-        const fullRefresh = await apiClient.getMessages("everyone", { limit: MESSAGE_PAGE_SIZE });
+        const fullRefresh = await apiClient.getMessages(channelId, { limit: MESSAGE_PAGE_SIZE });
         if (fullRefresh.length < MESSAGE_PAGE_SIZE) {
-          this.reachedOldestMessage = true;
+          channel.reachedOldestMessage = true;
         }
         if (fullRefresh.length > 0) {
-          this.mergeMessages(fullRefresh);
+          this.mergeMessages(channelId, fullRefresh);
           return;
         }
-        this.lastCursor = null;
+        channel.lastCursor = null;
       }
-      this.persistChannelState();
+      this.persistChannelState(channelId);
       return;
     } catch {
-      const messages = await apiClient.getMessages("everyone", { limit: MESSAGE_PAGE_SIZE });
+      const messages = await apiClient.getMessages(channelId, { limit: MESSAGE_PAGE_SIZE });
       if (messages.length < MESSAGE_PAGE_SIZE) {
-        this.reachedOldestMessage = true;
+        channel.reachedOldestMessage = true;
       }
       if (messages.length > 0) {
-        this.mergeMessages(messages);
+        this.mergeMessages(channelId, messages);
         return;
       }
-      this.persistChannelState();
+      this.persistChannelState(channelId);
     }
   }
 
-  private async fetchOlderMessages(before: string): Promise<void> {
-    const messages = await apiClient.getMessages("everyone", {
+  private async fetchOlderMessages(channelId: string, before: string): Promise<void> {
+    const channel = this.ensureChannelState(channelId);
+    const messages = await apiClient.getMessages(channelId, {
       limit: MESSAGE_PAGE_SIZE,
       before,
     });
     if (messages.length < MESSAGE_PAGE_SIZE) {
-      this.reachedOldestMessage = true;
+      channel.reachedOldestMessage = true;
     }
     if (messages.length === 0) {
-      this.persistChannelState();
+      this.persistChannelState(channelId);
       return;
     }
-    this.mergeMessages(messages, { notifyMentions: false });
+    this.mergeMessages(channelId, messages, { notifyMentions: false });
   }
 
-  private mergeMessages(messages: ChatMessage[], options?: { notifyMentions?: boolean }): void {
-    this.reconcilePendingMessages(messages);
+  private mergeMessages(
+    channelIdOrMessages: string | ChatMessage[],
+    maybeMessages?: ChatMessage[] | { notifyMentions?: boolean },
+    maybeOptions?: { notifyMentions?: boolean },
+  ): 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
+      : maybeOptions;
+    const channel = this.ensureChannelState(channelId);
+    this.reconcilePendingMessages(channelId, 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 channel.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()]
+    channel.messages = [...merged.values()]
       .sort(compareMessages);
-    this.lastCursor = this.messages[this.messages.length - 1]?.id ?? this.lastCursor;
-    if (this.openViewCount > 0) {
-      this.markViewedThroughLatestMessage(false);
+    channel.lastCursor = channel.messages[channel.messages.length - 1]?.id ?? channel.lastCursor;
+    if (channel.openViewCount > 0) {
+      this.markViewedThroughLatestMessage(channelId, false);
     }
     if (options?.notifyMentions !== false) {
-      this.trackUnreadMentions([...incoming.values()]);
+      this.trackUnreadMentions(channelId, [...incoming.values()]);
     }
-    this.persistTranscript();
-    this.emit();
+    this.persistTranscript(channelId);
+    this.emit(channelId);
   }
 
   private persistSession(): void {
@@ -609,67 +847,73 @@ export class ChatController {
     });
   }
 
-  private persistChannelState(): void {
-    this.clearDraftSyncTimer();
-    this.writeChannelState();
+  private persistChannelState(channelId: string): void {
+    const channel = this.ensureChannelState(channelId);
+    this.clearDraftSyncTimer(channel);
+    this.writeChannelState(channelId);
   }
 
-  private writeChannelState(): void {
+  private writeChannelState(channelId: string): void {
+    const channel = this.ensureChannelState(channelId);
     const value = {
-      draft: this.draft,
-      replyToId: this.replyToId,
-      lastCursor: this.lastCursor,
-      lastViewedMessageId: this.lastViewedMessageId,
+      draft: channel.draft,
+      replyToId: channel.replyToId,
+      lastCursor: channel.lastCursor,
+      lastViewedMessageId: channel.lastViewedMessageId,
     } satisfies PersistedChannelState;
-    this.resume?.setState(CHANNEL_STATE_KEY, value, {
+    this.resume?.setState(channelStateKey(channelId), value, {
       schemaVersion: CHANNEL_SCHEMA_VERSION,
     });
-    this.persistence?.setState(CHANNEL_STATE_KEY, value, {
+    this.persistence?.setState(channelStateKey(channelId), value, {
       schemaVersion: CHANNEL_SCHEMA_VERSION,
     });
   }
 
-  private scheduleDraftSync(): void {
-    this.clearDraftSyncTimer();
-    this.draftSyncTimer = setTimeout(() => {
-      this.draftSyncTimer = null;
-      this.writeChannelState();
-      this.emit();
+  private scheduleDraftSync(channelId: string): void {
+    const channel = this.ensureChannelState(channelId);
+    this.clearDraftSyncTimer(channel);
+    channel.draftSyncTimer = setTimeout(() => {
+      channel.draftSyncTimer = null;
+      this.writeChannelState(channelId);
+      this.emit(channelId);
     }, DRAFT_SYNC_DEBOUNCE_MS);
-    this.draftSyncTimer.unref?.();
+    channel.draftSyncTimer.unref?.();
   }
 
-  private clearDraftSyncTimer(): void {
-    if (!this.draftSyncTimer) return;
-    clearTimeout(this.draftSyncTimer);
-    this.draftSyncTimer = null;
+  private clearDraftSyncTimer(channel: ChannelRuntimeState): void {
+    if (!channel.draftSyncTimer) return;
+    clearTimeout(channel.draftSyncTimer);
+    channel.draftSyncTimer = null;
   }
 
-  private flushDraftSync(): void {
-    if (!this.draftSyncTimer) return;
-    this.clearDraftSyncTimer();
-    this.writeChannelState();
+  private flushDraftSync(channelId: string): void {
+    const channel = this.ensureChannelState(channelId);
+    if (!channel.draftSyncTimer) return;
+    this.clearDraftSyncTimer(channel);
+    this.writeChannelState(channelId);
   }
 
-  private persistTranscript(): void {
-    if (this.messages.length === 0) {
-      this.persistence?.deleteResource(TRANSCRIPT_KIND, "everyone", { sourceKey: TRANSCRIPT_SOURCE });
-      this.persistChannelState();
+  private persistTranscript(channelId: string): void {
+    const channel = this.ensureChannelState(channelId);
+    if (channel.messages.length === 0) {
+      this.persistence?.deleteResource(TRANSCRIPT_KIND, channelId, { sourceKey: TRANSCRIPT_SOURCE });
+      this.persistChannelState(channelId);
       return;
     }
 
-    this.persistence?.setResource(TRANSCRIPT_KIND, "everyone", {
-      messages: this.messages.slice(-MAX_CACHED_MESSAGES),
+    this.persistence?.setResource(TRANSCRIPT_KIND, channelId, {
+      messages: channel.messages.slice(-MAX_CACHED_MESSAGES),
     } satisfies PersistedTranscript, {
       sourceKey: TRANSCRIPT_SOURCE,
       schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
       cachePolicy: TRANSCRIPT_CACHE_POLICY,
     });
-    this.persistChannelState();
+    this.persistChannelState(channelId);
   }
 
-  private trackUnreadMentions(messages: ChatMessage[]): void {
-    if (this.openViewCount > 0) {
+  private trackUnreadMentions(channelId: string, messages: ChatMessage[]): void {
+    const channel = this.ensureChannelState(channelId);
+    if (channel.openViewCount > 0) {
       return;
     }
 
@@ -687,25 +931,26 @@ export class ChatController {
     }
     this.notifyFn({
       title: "Gloomberb chat",
-      body: `${freshMentions.length} new mentions in #everyone.`,
+      body: `${freshMentions.length} new mentions in #${channelId}.`,
       type: "info",
       desktop: "when-inactive",
     });
   }
 
-  private getUnreadMentionCount(): number {
-    return this.getUnreadMentionMessages().length;
+  private getUnreadMentionCount(channelId: string): number {
+    return this.getUnreadMentionMessages(channelId).length;
   }
 
-  private getUnreadMentionMessages(): ChatMessage[] {
-    if (!this.lastViewedMessageId) {
-      return this.getMentionMessages(this.messages);
+  private getUnreadMentionMessages(channelId: string): ChatMessage[] {
+    const channel = this.ensureChannelState(channelId);
+    if (!channel.lastViewedMessageId) {
+      return this.getMentionMessages(channel.messages);
     }
 
-    const viewedIndex = this.messages.findIndex((message) => message.id === this.lastViewedMessageId);
+    const viewedIndex = channel.messages.findIndex((message) => message.id === channel.lastViewedMessageId);
     const unseenMessages = viewedIndex >= 0
-      ? this.messages.slice(viewedIndex + 1)
-      : this.messages;
+      ? channel.messages.slice(viewedIndex + 1)
+      : channel.messages;
     return this.getMentionMessages(unseenMessages);
   }
 
@@ -718,31 +963,33 @@ export class ChatController {
     ));
   }
 
-  private markViewedThroughLatestMessage(persist = true): boolean {
-    const latestMessageId = this.messages[this.messages.length - 1]?.id ?? null;
-    if (this.lastViewedMessageId === latestMessageId) {
+  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) {
       return false;
     }
-    this.lastViewedMessageId = latestMessageId;
+    channel.lastViewedMessageId = latestMessageId;
     if (persist) {
-      this.persistChannelState();
+      this.persistChannelState(channelId);
     }
     return true;
   }
 
-  private getVisibleMessages(): ChatMessage[] {
-    return [...this.messages, ...this.pendingMessages]
+  private getVisibleMessages(channelId: string): ChatMessage[] {
+    const channel = this.ensureChannelState(channelId);
+    return [...channel.messages, ...channel.pendingMessages]
       .sort(compareMessages);
   }
 
-  private createPendingMessage(content: string, replyToId?: string): ChatMessage {
+  private createPendingMessage(channelId: string, content: string, replyToId?: string): ChatMessage {
     const replyToMessage = replyToId
-      ? this.getVisibleMessages().find((message) => message.id === replyToId) ?? null
+      ? this.getVisibleMessages(channelId).find((message) => message.id === replyToId) ?? null
       : null;
     const pendingId = `local:${Date.now()}:${this.pendingMessageSeq += 1}`;
     return {
       id: pendingId,
-      channelId: "everyone",
+      channelId,
       content,
       replyToId: replyToId ?? null,
       createdAt: new Date().toISOString(),
@@ -762,10 +1009,11 @@ export class ChatController {
     };
   }
 
-  private reconcilePendingMessages(messages: ChatMessage[]): void {
-    if (this.pendingMessages.length === 0 || messages.length === 0) return;
+  private reconcilePendingMessages(channelId: string, messages: ChatMessage[]): void {
+    const channel = this.ensureChannelState(channelId);
+    if (channel.pendingMessages.length === 0 || messages.length === 0) return;
 
-    const remaining = [...this.pendingMessages];
+    const remaining = [...channel.pendingMessages];
     for (const incoming of messages) {
       const incomingMs = toTimestampMillis(incoming.createdAt);
       const pendingIndex = remaining.findIndex((pending) => (
@@ -778,7 +1026,7 @@ export class ChatController {
         remaining.splice(pendingIndex, 1);
       }
     }
-    this.pendingMessages = remaining;
+    channel.pendingMessages = remaining;
   }
 }