gloomberb 0.8.1 → 0.9.0

package/src/plugins/builtin/chat/channel-labels.ts

@@ -0,0 +1,53 @@
+import type { ChatChannel } from "../../../api-client";
+import { normalizeChannelId } from "./controller/state";
+
+function normalizeMentionUsername(username: string | null | undefined): string | null {
+  const normalized = username?.trim().replace(/^@+/, "");
+  return normalized || null;
+}
+
+function formatMentionUsername(username: string | null | undefined): string | null {
+  const normalized = normalizeMentionUsername(username);
+  return normalized ? `@${normalized}` : null;
+}
+
+function formatDirectChannelLabel(channel: ChatChannel, fallbackId: string) {
+  const usernameLabel = formatMentionUsername(channel.dmUser?.username);
+  if (usernameLabel) return usernameLabel;
+
+  const displayName = channel.dmUser?.displayName?.trim();
+  if (displayName) return displayName;
+
+  const channelName = channel.name?.trim();
+  if (channelName && channelName !== channel.id) {
+    return channelName.startsWith("@")
+      ? formatMentionUsername(channelName) ?? channelName
+      : channelName;
+  }
+
+  return fallbackId.startsWith("dm:") ? "DM" : fallbackId;
+}
+
+export function formatChannelLabel(channel: ChatChannel | undefined, fallbackId: string) {
+  if (!channel) return fallbackId;
+  if (channel.kind === "direct") {
+    return formatDirectChannelLabel(channel, fallbackId);
+  }
+  if (channel.kind === "group") {
+    return channel.name?.trim() || "Group";
+  }
+  return channel.name?.trim() || fallbackId;
+}
+
+export function formatChatPaneTitle(channel: ChatChannel | undefined, fallbackId: string) {
+  const normalizedFallbackId = normalizeChannelId(fallbackId);
+  if (channel?.kind === "direct") {
+    return formatChannelLabel(channel, normalizedFallbackId);
+  }
+  if (channel?.kind === "group") {
+    return formatChannelLabel(channel, normalizedFallbackId);
+  }
+  if (!channel && normalizedFallbackId.startsWith("dm:")) return "DM";
+  if (!channel && (normalizedFallbackId.startsWith("grp:") || normalizedFallbackId.startsWith("group:"))) return "Group";
+  return `#${formatChannelLabel(channel, normalizedFallbackId)}`;
+}

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

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import type { ChatChannel } from "../../../api-client";
+import {
+  channelPrefix,
+  formatChannelLabel,
+  formatChatPaneTitle,
+} from "./channels";
+
+describe("chat channel labels", () => {
+  test("formats direct-message labels and titles with one mention prefix", () => {
+    const channel: ChatChannel = {
+      id: "dm:c7f89ce26f9da83d6be08a4838738074",
+      name: "@risto",
+      kind: "direct",
+      created_at: "2026-05-27T10:30:03.712Z",
+      dmUser: { id: "u2", username: "@risto", displayName: "Risto" },
+    };
+
+    expect(formatChannelLabel(channel, channel.id)).toBe("@risto");
+    expect(channelPrefix(channel, true)).toBe(" ");
+    expect(formatChatPaneTitle(channel, channel.id)).toBe("@risto");
+    expect(formatChatPaneTitle(undefined, channel.id)).toBe("DM");
+  });
+
+  test("uses a neutral group title before private channel metadata loads", () => {
+    expect(formatChatPaneTitle(undefined, "grp:93f14c6b9827c30f")).toBe("Group");
+  });
+});

package/src/plugins/builtin/chat/channels.ts

@@ -1,6 +1,10 @@
 import type { CommandResultDef, GloomPluginContext } from "../../../types/plugin";
-import type { ChatChannel } from "../../../api-client";
+import type { ChatChannel, ChatChannelState } from "../../../api-client";
+import type { AppConfig, PaneInstanceConfig } from "../../../types/config";
 import { chatController } from "./controller";
+import { formatChannelLabel } from "./channel-labels";
+
+export { formatChannelLabel, formatChatPaneTitle } from "./channel-labels";
 
 export const DEFAULT_CHAT_CHANNEL_ID = "everyone";
 export const LAST_VISITED_CHAT_CHANNEL_KEY = "lastChatChannelId";
@@ -21,15 +25,28 @@ export function getLastVisitedChatChannelId(config: { pluginConfig: Record<strin
   return normalizeChannelId(config.pluginConfig["gloomberb-cloud"]?.[LAST_VISITED_CHAT_CHANNEL_KEY] as string | undefined);
 }
 
-export function formatChannelLabel(channel: ChatChannel | undefined, fallbackId: string) {
-  if (!channel) return fallbackId;
-  if (channel.kind === "direct") {
-    return channel.dmUser?.username ? `@${channel.dmUser.username}` : channel.dmUser?.displayName ?? "DM";
-  }
-  if (channel.kind === "group") {
-    return channel.name?.trim() || "Group";
-  }
-  return channel.name?.trim() || fallbackId;
+export function findChatPaneInstanceForChannel(config: AppConfig, channelId: string): PaneInstanceConfig | undefined {
+  const normalizedChannelId = normalizeChannelId(channelId);
+  return config.layout.instances.find((instance) => (
+    instance.paneId === "chat"
+    && normalizeChannelId(typeof instance.settings?.channelId === "string" ? instance.settings.channelId : null) === normalizedChannelId
+  ));
+}
+
+export function getPreferredChatOpenChannelId(
+  config: AppConfig,
+  snapshot?: { channels: ChatChannel[]; channelStates: ChatChannelState[] },
+) {
+  if (!snapshot) return getLastVisitedChatChannelId(config);
+  const channelById = new Map(snapshot.channels.map((channel) => [channel.id, channel]));
+  const unreadStates = snapshot.channelStates
+    .filter((state) => state.unreadCount > 0 && channelById.has(state.channelId))
+    .sort((a, b) => b.unreadCount - a.unreadCount);
+  const unreadConversation = unreadStates.find((state) => {
+    const kind = channelById.get(state.channelId)?.kind ?? "public";
+    return kind === "direct" || kind === "group";
+  });
+  return normalizeChannelId(unreadConversation?.channelId ?? unreadStates[0]?.channelId ?? getLastVisitedChatChannelId(config));
 }
 
 function conversationDetail(channel: ChatChannel): string {
@@ -63,20 +80,20 @@ export function hasOnlyDmUsernameArgs(value: string): boolean {
   return parts.length > 0 && parts.every((part) => CHAT_USERNAME_ARG.test(part));
 }
 
-function openChatChannelFromCommand(ctx: GloomPluginContext, channelId: string): void {
+function openChatChannelFromCommand(ctx: Pick<GloomPluginContext, "createPaneFromTemplate" | "focusPane" | "getConfig">, channelId: string): void {
+  const existingInstance = findChatPaneInstanceForChannel(ctx.getConfig(), channelId);
+  if (existingInstance) {
+    ctx.focusPane(existingInstance.instanceId);
+    return;
+  }
   ctx.createPaneFromTemplate("new-chat-pane", { arg: channelId });
 }
 
 export function openDefaultChatFromCommand(
-  ctx: Pick<GloomPluginContext, "createPaneFromTemplate" | "getConfig" | "showPane">,
+  ctx: Pick<GloomPluginContext, "createPaneFromTemplate" | "focusPane" | "getConfig">,
 ): void {
   const config = ctx.getConfig();
-  const hasChatPane = config.layout.instances.some((instance) => instance.paneId === "chat");
-  if (hasChatPane) {
-    ctx.showPane("chat");
-    return;
-  }
-  ctx.createPaneFromTemplate("new-chat-pane", { arg: getLastVisitedChatChannelId(config) });
+  openChatChannelFromCommand(ctx, getPreferredChatOpenChannelId(config, chatController.getSnapshot()));
 }
 
 export async function openDmTargetFromCommand(ctx: GloomPluginContext, usernames: string[]): Promise<void> {
@@ -143,7 +160,7 @@ export function buildDmCommandResults(ctx: GloomPluginContext, arg: string): Com
 }
 
 export function channelPrefix(channel: ChatChannel | undefined, active: boolean) {
-  if (channel?.kind === "direct") return active ? "@" : " ";
+  if (channel?.kind === "direct") return " ";
   if (channel?.kind === "group") return active ? "+" : " ";
   return active ? "#" : " ";
 }

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

@@ -9,7 +9,7 @@ import type { ChatMessage } from "../../../api-client";
 import { apiClient } from "../../../api-client";
 import { PluginRenderProvider } from "../../runtime";
 import { setSharedRegistryForTests } from "../../registry";
-import { ChatStatusWidget } from ".";
+import { ChatContent, ChatStatusWidget } from ".";
 import {
   cleanupChatTest,
   createChatTestControls,
@@ -17,6 +17,7 @@ import {
   createHarness,
   hexToRgbaInts,
   installChatApiTestDefaults,
+  installServerChannels,
   lineText,
   makeMessage,
   type ChatTestSetup,
@@ -29,6 +30,21 @@ function setup(): ChatTestSetup {
 }
 const { flushFrame, emitKeypress } = createChatTestControls(setup);
 
+function recentChatTimestamp(offsetMs = 60_000) {
+  return new Date(Date.now() - offsetMs).toISOString();
+}
+
+function makeOwnMessage(content = "typo", createdAt = recentChatTimestamp()): ChatMessage {
+  return {
+    id: "m-own",
+    channelId: "everyone",
+    content,
+    replyToId: null,
+    createdAt,
+    user: { id: "u0", username: "vince", displayName: "Vince" },
+  };
+}
+
 beforeEach(() => {
   installChatApiTestDefaults();
 });
@@ -39,6 +55,42 @@ afterEach(async () => {
 });
 
 describe("ChatContent", () => {
+  test("keeps a persisted DM selected while private channels refresh", async () => {
+    const controller = createController();
+    const dmChannelId = "dm:test";
+    installServerChannels(controller, [
+      { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
+    ]);
+    controller.refreshChannels = async () => {};
+    controller.refreshPresence = async () => {};
+    controller.refreshSession = async () => {};
+    controller.refreshChannelMessages = async () => {};
+    const channelChanges: string[] = [];
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <PluginRenderProvider pluginId="gloomberb-cloud" runtime={createTestPluginRuntime()}>
+            <ChatContent
+              controller={controller}
+              width={60}
+              height={12}
+              focused
+              channelId={dmChannelId}
+              onChannelChange={(nextChannelId) => channelChanges.push(nextChannelId)}
+            />
+          </PluginRenderProvider>
+        </AppContext>,
+        { width: 60, height: 12 },
+      );
+    });
+
+    await flushFrame();
+
+    expect(channelChanges).toEqual([]);
+  });
+
   test("focuses the prompt on click and preserves typing order", async () => {
     const controller = createController();
 
@@ -179,6 +231,108 @@ describe("ChatContent", () => {
     expect(bodyLine).not.toContain("Reply");
   });
 
+  test("shows the edit action next to reply for the latest own message", async () => {
+    const ownMessage = makeOwnMessage();
+    const controller = createController({
+      messages: [makeMessage(1), ownMessage],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, {
+        width: 72,
+        height: 12,
+      }), {
+        width: 72,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    await emitKeypress({ name: "up", sequence: "\u001b[A" });
+    await flushFrame();
+
+    const lines = setup().captureCharFrame().split("\n");
+    const headerLine = lines.find((line) => line.includes("vince"));
+
+    expect(headerLine).toContain("Reply");
+    expect(headerLine).toContain("Edit");
+  });
+
+  test("hides the edit action after the edit window expires", async () => {
+    const ownMessage = makeOwnMessage("typo", recentChatTimestamp(16 * 60_000));
+    const controller = createController({
+      messages: [makeMessage(1), ownMessage],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, {
+        width: 72,
+        height: 12,
+      }), {
+        width: 72,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    await emitKeypress({ name: "up", sequence: "\u001b[A" });
+    await flushFrame();
+
+    const lines = setup().captureCharFrame().split("\n");
+    const headerLine = lines.find((line) => line.includes("vince"));
+
+    expect(headerLine).toContain("Reply");
+    expect(headerLine).not.toContain("Edit");
+  });
+
+  test("up arrow from an empty focused composer edits the latest own message", async () => {
+    const ownMessage = makeOwnMessage();
+    const controller = createController({
+      messages: [makeMessage(1), ownMessage],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, {
+        width: 72,
+        height: 12,
+      }), {
+        width: 72,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const lines = setup().captureCharFrame().split("\n");
+    const inputRow = lines.findIndex((line) => line.includes("Type a message..."));
+    const inputCol = lines[inputRow]?.indexOf("Type a message...") ?? -1;
+    expect(inputRow).toBeGreaterThanOrEqual(0);
+    expect(inputCol).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await setup().mockMouse.click(inputCol + 1, inputRow);
+      await setup().renderOnce();
+      await setup().renderOnce();
+    });
+
+    await emitKeypress({ name: "up", sequence: "\u001b[A" });
+    await flushFrame();
+
+    const frame = setup().captureCharFrame();
+    expect(frame).toContain("editing");
+    expect(frame).toContain("> typo");
+
+    await act(async () => {
+      await setup().mockInput.typeText(" fix");
+      await setup().renderOnce();
+      await setup().renderOnce();
+    });
+
+    expect(setup().captureCharFrame()).toContain("> typo fix");
+  });
+
   test("down arrow from the newest selected message returns focus to the composer", async () => {
     const controller = createController({
       messages: [makeMessage(1), makeMessage(2)],
@@ -867,6 +1021,36 @@ describe("ChatContent", () => {
     expect(frame).toContain("https://example.com/story.");
   });
 
+  test("keeps long link query strings from spilling into following terminal rows", async () => {
+    const controller = createController({
+      messages: [{
+        id: "m1",
+        channelId: "everyone",
+        content: "again:\nhttps://github.com/houmain/keymapper/issues?weird_one=the_rest_of the query parameters got lost entirely :)",
+        replyToId: null,
+        createdAt: "2026-03-28T00:00:00.000Z",
+        user: { id: "u1", username: "vince", displayName: "Vince" },
+      }],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, {
+        width: 60,
+        height: 12,
+      }), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const frame = setup().captureCharFrame();
+    expect(frame).toContain("https://github.com/houmain/keymapper/issues?weird_one=");
+    expect(frame).toContain("the_rest_of the query parameters got lost entirely :)");
+    expect(frame).not.toContain("therquery=parametersfgot");
+  });
+
   test("shows a saved-login read-only footer when a session token is cached", async () => {
     const controller = createController({
       sessionToken: "token-123",
@@ -993,13 +1177,17 @@ describe("ChatContent", () => {
       sessionToken: "token-123",
       user: { id: "u1", username: "vince", emailVerified: true },
     });
-    const openedPanes: string[] = [];
+    const openedTemplates: Array<{ templateId: string; options?: { arg?: string } }> = [];
+    const focusedPanes: string[] = [];
     const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
     state.config.disabledPlugins = [];
 
     const runtime = createTestPluginRuntime({
-      showPane(paneId: string) {
-        openedPanes.push(paneId);
+      createPaneFromTemplate(templateId: string, options?: { arg?: string }) {
+        openedTemplates.push({ templateId, options });
+      },
+      focusPane(paneId: string) {
+        focusedPanes.push(paneId);
       },
     });
 
@@ -1042,7 +1230,78 @@ describe("ChatContent", () => {
       await setup().renderOnce();
     });
 
-    expect(openedPanes).toEqual(["chat"]);
+    expect(openedTemplates).toEqual([]);
+    expect(focusedPanes).toHaveLength(1);
+    expect(focusedPanes[0]?.startsWith("chat:")).toBe(true);
+  });
+
+  test("opens an unread direct-message channel from the status widget", async () => {
+    const controller = createController({
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    });
+    const dmChannelId = "dm:test";
+    installServerChannels(controller, [
+      { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
+      {
+        id: dmChannelId,
+        name: "@bob",
+        kind: "direct",
+        created_at: "2026-05-27T10:30:03.712Z",
+        dmUser: { id: "u2", username: "bob", displayName: "Bob" },
+      },
+    ]);
+    const openedTemplates: Array<{ templateId: string; options?: { arg?: string } }> = [];
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
+    state.config.disabledPlugins = [];
+
+    const runtime = createTestPluginRuntime({
+      createPaneFromTemplate(templateId: string, options?: { arg?: string }) {
+        openedTemplates.push({ templateId, options });
+      },
+    });
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <PluginRenderProvider pluginId="gloomberb-cloud" runtime={runtime}>
+            <ChatStatusWidget controller={controller} />
+          </PluginRenderProvider>
+        </AppContext>,
+        { width: 40, height: 1 },
+      );
+    });
+
+    await flushFrame();
+
+    await act(async () => {
+      (controller as any).mergeMessages(dmChannelId, [{
+        id: "dm-m1",
+        channelId: dmChannelId,
+        content: "private ping",
+        replyToId: null,
+        createdAt: "2026-05-27T10:31:00.000Z",
+        user: { id: "u2", username: "bob", displayName: "Bob" },
+      } satisfies ChatMessage]);
+    });
+    await flushFrame();
+
+    const frame = setup().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 setup().mockMouse.click(badgeCol + 1, 0);
+      await setup().renderOnce();
+      await setup().renderOnce();
+    });
+
+    expect(openedTemplates).toEqual([{ templateId: "new-chat-pane", options: { arg: dmChannelId } }]);
   });
 
 });

package/src/plugins/builtin/chat/content/channel-navigation.ts

@@ -1,12 +1,19 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
 import type { ChatChannel, ChatUserSummary } from "../../../../api-client";
+import { useThrottledCommitValue } from "../../../../react/use-throttled-commit-value";
 import {
   DEFAULT_CHAT_CHANNEL_ID,
   normalizeChannelId,
 } from "../channels";
 import type { ChatContentController } from "./types";
 
+const CHANNEL_NAVIGATION_COMMIT_DELAY_MS = 150;
+
+function isConversationChannelId(channelId: string): boolean {
+  return channelId.startsWith("dm:") || channelId.startsWith("grp:") || channelId.startsWith("group:");
+}
+
 export function useChatChannelNavigation({
   blurInput,
   channelId,
@@ -34,15 +41,16 @@ export function useChatChannelNavigation({
   resetTranscriptSelection: () => void;
   showChannelSidebar: boolean;
 }): {
-  changeChannel: (nextChannelId: string) => void;
   cycleChannel: (direction: 1 | -1) => boolean;
   directExpanded: boolean;
   focusChannelSidebar: () => boolean;
   focusChatContent: () => boolean;
   moveSidebarChannelSelection: (direction: "up" | "down") => boolean;
   openDirectMessage: (target: ChatUserSummary) => Promise<void>;
+  selectSidebarChannel: (channelId: string) => void;
   setDirectExpanded: Dispatch<SetStateAction<boolean>>;
   setSidebarFocused: (nextFocused: boolean) => void;
+  sidebarCursorChannelId: string;
   sidebarFocused: boolean;
   sidebarFocusedRef: MutableRefObject<boolean>;
 } {
@@ -66,6 +74,13 @@ export function useChatChannelNavigation({
     resetTranscriptSelection();
     onChannelChange?.(normalized);
   }, [channelIdRef, onChannelChange, resetTranscriptSelection]);
+  const {
+    value: sidebarCursorChannelId,
+    valueRef: sidebarCursorChannelIdRef,
+    setValue: setSidebarCursorChannelId,
+    flushValue: flushSidebarCursorChannelId,
+    replaceValue: replaceSidebarCursorChannelId,
+  } = useThrottledCommitValue(channelId, changeChannel, CHANNEL_NAVIGATION_COMMIT_DELAY_MS);
 
   const openDirectMessage = useCallback(async (target: ChatUserSummary) => {
     if (!target.id && !target.username) return;
@@ -75,14 +90,16 @@ export function useChatChannelNavigation({
         username: target.username ?? undefined,
       });
       setDirectExpanded(true);
-      changeChannel(channel.id);
+      setSidebarCursorChannelId(channel.id, { immediate: true });
       closeProfilePopover();
     } catch {}
-  }, [changeChannel, closeProfilePopover, controller]);
+  }, [closeProfilePopover, controller, setSidebarCursorChannelId]);
 
   useEffect(() => {
     if (!onChannelChange || channelsLoading || channels.length === 0) return;
     if (channels.some((channel) => channel.id === channelId)) return;
+    // DM/group panes can remount before the private channel catalog is refreshed.
+    if (isConversationChannelId(channelId)) return;
     const fallbackChannelId = channels.find((channel) => channel.id === DEFAULT_CHAT_CHANNEL_ID)?.id
       ?? channels[0]?.id;
     if (fallbackChannelId) {
@@ -103,9 +120,9 @@ export function useChatChannelNavigation({
     const nextIndex = (currentIndex + direction + channels.length) % channels.length;
     const nextChannel = channels[nextIndex];
     if (!nextChannel) return false;
-    changeChannel(nextChannel.id);
+    setSidebarCursorChannelId(nextChannel.id, { immediate: true });
     return true;
-  }, [changeChannel, channelIdRef, channels, onChannelChange]);
+  }, [channelIdRef, channels, onChannelChange, setSidebarCursorChannelId]);
 
   const focusChannelSidebar = useCallback(() => {
     if (!showChannelSidebar || !onChannelChange) return false;
@@ -113,28 +130,49 @@ export function useChatChannelNavigation({
       blurInput();
     }
     resetTranscriptSelection();
+    replaceSidebarCursorChannelId(channelId);
     setSidebarFocused(true);
     return true;
-  }, [blurInput, inputFocused, onChannelChange, resetTranscriptSelection, setSidebarFocused, showChannelSidebar]);
+  }, [
+    blurInput,
+    channelId,
+    inputFocused,
+    onChannelChange,
+    replaceSidebarCursorChannelId,
+    resetTranscriptSelection,
+    setSidebarFocused,
+    showChannelSidebar,
+  ]);
 
   const focusChatContent = useCallback(() => {
     if (!showChannelSidebar) return false;
+    flushSidebarCursorChannelId(sidebarCursorChannelIdRef.current);
     setSidebarFocused(false);
     return true;
-  }, [setSidebarFocused, showChannelSidebar]);
+  }, [flushSidebarCursorChannelId, setSidebarFocused, showChannelSidebar, sidebarCursorChannelIdRef]);
 
   const moveSidebarChannelSelection = useCallback((direction: "up" | "down") => {
     if (!showChannelSidebar || sidebarNavigationChannels.length <= 1 || !onChannelChange) return false;
-    const currentIndex = sidebarNavigationChannels.findIndex((channel) => channel.id === channelIdRef.current);
+    const currentIndex = sidebarNavigationChannels.findIndex((channel) => channel.id === sidebarCursorChannelIdRef.current);
     const baseIndex = currentIndex >= 0 ? currentIndex : 0;
     const nextIndex = direction === "down"
       ? Math.min(baseIndex + 1, sidebarNavigationChannels.length - 1)
       : Math.max(baseIndex - 1, 0);
     const nextChannel = sidebarNavigationChannels[nextIndex];
     if (!nextChannel || nextIndex === baseIndex) return true;
-    changeChannel(nextChannel.id);
+    setSidebarCursorChannelId(nextChannel.id);
     return true;
-  }, [changeChannel, channelIdRef, onChannelChange, showChannelSidebar, sidebarNavigationChannels]);
+  }, [
+    onChannelChange,
+    setSidebarCursorChannelId,
+    showChannelSidebar,
+    sidebarCursorChannelIdRef,
+    sidebarNavigationChannels,
+  ]);
+
+  const selectSidebarChannel = useCallback((nextChannelId: string) => {
+    setSidebarCursorChannelId(nextChannelId, { immediate: true });
+  }, [setSidebarCursorChannelId]);
 
   useEffect(() => {
     if (focused && showChannelSidebar) return;
@@ -142,15 +180,16 @@ export function useChatChannelNavigation({
   }, [focused, setSidebarFocused, showChannelSidebar]);
 
   return {
-    changeChannel,
     cycleChannel,
     directExpanded,
     focusChannelSidebar,
     focusChatContent,
     moveSidebarChannelSelection,
     openDirectMessage,
+    selectSidebarChannel,
     setDirectExpanded,
     setSidebarFocused,
+    sidebarCursorChannelId,
     sidebarFocused,
     sidebarFocusedRef,
   };