gloomberb 0.8.0 → 0.8.2

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

@@ -7,6 +7,10 @@ import {
 } from "../channels";
 import type { ChatContentController } from "./types";
 
+function isConversationChannelId(channelId: string): boolean {
+  return channelId.startsWith("dm:") || channelId.startsWith("grp:") || channelId.startsWith("group:");
+}
+
 export function useChatChannelNavigation({
   blurInput,
   channelId,
@@ -83,6 +87,8 @@ export function useChatChannelNavigation({
   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) {

package/src/plugins/builtin/chat/content/composer-runtime.test.tsx

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useRef } from "react";
+import type { ChatMessage } from "../../../../api-client";
+import { testRender } from "../../../../renderers/opentui/test-utils";
+import { useChatComposerRuntime } from "./composer-runtime";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup?.renderer.destroy();
+    });
+  }
+  testSetup = undefined;
+});
+
+describe("useChatComposerRuntime", () => {
+  test("sends to the pending channel ref instead of the stale rendered channel", async () => {
+    const sent: Array<{ channelId: string; content: string; replyToId?: string }> = [];
+    let sendMessage = () => {};
+
+    function Harness() {
+      const applyingExternalDraftRef = useRef(false);
+      const channelIdRef = useRef("dm:test");
+      const inputRef = useRef(null);
+      const inputValueRef = useRef("PM reply test #2");
+      sendMessage = useChatComposerRuntime({
+        applyingExternalDraftRef,
+        blurInput: () => {},
+        canSend: true,
+        channelId: "everyone",
+        channelIdRef,
+        contentWidth: 80,
+        controller: {
+          send: () => false,
+          sendToChannel: (channelId, content, replyToId) => {
+            sent.push({ channelId, content, replyToId });
+            return true;
+          },
+          openDirectChannel: async () => { throw new Error("not used"); },
+          openGroupChannel: async () => { throw new Error("not used"); },
+          setDraft: () => {},
+          setChannelDraft: () => {},
+          setReplyToId: () => {},
+          setChannelReplyToId: () => {},
+        } as any,
+        focusInput: () => {},
+        focused: true,
+        inputFocused: true,
+        inputRef,
+        inputValueRef,
+        messages: [],
+        onChannelChange: () => {},
+        replyTo: null,
+        setDirectExpanded: () => {},
+        setFollowMessages: () => {},
+        setReplyTo: () => {},
+        setSelectedIdx: () => {},
+        updateComposerRows: () => {},
+        useDefaultControllerChannel: false,
+      }).sendMessage;
+      return null;
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<Harness />, { width: 1, height: 1 });
+    });
+
+    await act(async () => {
+      sendMessage();
+      await testSetup?.renderOnce();
+    });
+
+    expect(sent).toEqual([{ channelId: "dm:test", content: "PM reply test #2", replyToId: undefined }]);
+  });
+
+  test("drops a reply target from a different channel before sending", async () => {
+    const sent: Array<{ channelId: string; content: string; replyToId?: string }> = [];
+    let sendMessage = () => {};
+    const staleReply: ChatMessage = {
+      id: "public-reply",
+      channelId: "everyone",
+      content: "public message",
+      replyToId: null,
+      createdAt: "2026-05-27T10:26:44.737Z",
+      user: { id: "u2", username: "vince", displayName: "Vince" },
+    };
+
+    function Harness() {
+      const applyingExternalDraftRef = useRef(false);
+      const channelIdRef = useRef("dm:test");
+      const inputRef = useRef(null);
+      const inputValueRef = useRef("replying in DM");
+      sendMessage = useChatComposerRuntime({
+        applyingExternalDraftRef,
+        blurInput: () => {},
+        canSend: true,
+        channelId: "dm:test",
+        channelIdRef,
+        contentWidth: 80,
+        controller: {
+          send: () => false,
+          sendToChannel: (channelId, content, replyToId) => {
+            sent.push({ channelId, content, replyToId });
+            return true;
+          },
+          openDirectChannel: async () => { throw new Error("not used"); },
+          openGroupChannel: async () => { throw new Error("not used"); },
+          setDraft: () => {},
+          setChannelDraft: () => {},
+          setReplyToId: () => {},
+          setChannelReplyToId: () => {},
+        } as any,
+        focusInput: () => {},
+        focused: true,
+        inputFocused: true,
+        inputRef,
+        inputValueRef,
+        messages: [],
+        onChannelChange: () => {},
+        replyTo: staleReply,
+        setDirectExpanded: () => {},
+        setFollowMessages: () => {},
+        setReplyTo: () => {},
+        setSelectedIdx: () => {},
+        updateComposerRows: () => {},
+        useDefaultControllerChannel: false,
+      }).sendMessage;
+      return null;
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<Harness />, { width: 1, height: 1 });
+    });
+
+    await act(async () => {
+      sendMessage();
+      await testSetup?.renderOnce();
+    });
+
+    expect(sent).toEqual([{ channelId: "dm:test", content: "replying in DM", replyToId: undefined }]);
+  });
+});