gloomberb 0.8.1 → 0.9.0

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 }]);
+  });
+});

package/src/plugins/builtin/chat/content/composer-runtime.ts

@@ -12,6 +12,26 @@ interface MutableRef<T> {
   current: T;
 }
 
+function moveComposerCursorToEnd(textarea: TextareaRenderable, draft: string) {
+  const offset = draft.length;
+  const editBuffer = textarea.editBuffer as typeof textarea.editBuffer & {
+    setCursorByOffset?: (offset: number) => void;
+  };
+  if (typeof editBuffer.setCursorByOffset === "function") {
+    editBuffer.setCursorByOffset(offset);
+    return;
+  }
+  if (typeof textarea.setCursorOffset === "function") {
+    textarea.setCursorOffset(offset);
+    return;
+  }
+  try {
+    textarea.cursorOffset = offset;
+  } catch {
+    // Some host renderers expose cursorOffset as read-only.
+  }
+}
+
 export function useChatComposerRuntime({
   applyingExternalDraftRef,
   blurInput,
@@ -27,7 +47,10 @@ export function useChatComposerRuntime({
   inputValueRef,
   messages,
   onChannelChange,
+  editingMessage,
+  latestEditableMessageId,
   replyTo,
+  setEditingMessage,
   setDirectExpanded,
   setFollowMessages,
   setReplyTo,
@@ -49,7 +72,10 @@ export function useChatComposerRuntime({
   inputValueRef: MutableRef<string>;
   messages: ChatMessage[];
   onChannelChange?: (channelId: string) => void;
+  editingMessage: ChatMessage | null;
+  latestEditableMessageId: string | null;
   replyTo: ChatMessage | null;
+  setEditingMessage: Dispatch<SetStateAction<ChatMessage | null>>;
   setDirectExpanded: Dispatch<SetStateAction<boolean>>;
   setFollowMessages: Dispatch<SetStateAction<boolean>>;
   setReplyTo: Dispatch<SetStateAction<ChatMessage | null>>;
@@ -59,6 +85,9 @@ export function useChatComposerRuntime({
 }) {
   const replyToRef = useRef(replyTo);
   replyToRef.current = replyTo;
+  const editingMessageRef = useRef(editingMessage);
+  editingMessageRef.current = editingMessage;
+  const editSubmittingRef = useRef(false);
 
   const focusComposer = useCallback(() => {
     setSelectedIdx(-1);
@@ -75,10 +104,40 @@ export function useChatComposerRuntime({
     }
   }, [channelId, controller, setReplyTo, useDefaultControllerChannel]);
 
+  const persistDraft = useCallback((draft: string) => {
+    if (useDefaultControllerChannel) {
+      controller.setDraft(draft);
+    } else {
+      controller.setChannelDraft(channelId, draft);
+    }
+  }, [channelId, controller, useDefaultControllerChannel]);
+
+  const replaceLocalComposer = useCallback((draft: string) => {
+    inputValueRef.current = draft;
+    updateComposerRows(draft);
+    const textarea = inputRef.current;
+    if (textarea && textarea.editBuffer.getText() !== draft) {
+      applyingExternalDraftRef.current = true;
+      try {
+        textarea.setText(draft);
+        moveComposerCursorToEnd(textarea, draft);
+      } finally {
+        applyingExternalDraftRef.current = false;
+      }
+    } else if (textarea) {
+      moveComposerCursorToEnd(textarea, draft);
+    }
+  }, [applyingExternalDraftRef, inputRef, inputValueRef, updateComposerRows]);
+
   const beginReplyTo = useCallback((index: number, options?: { deferFocus?: boolean }) => {
     if (!canSend || index < 0 || index >= messages.length) return;
     const nextReplyTo = messages[index] ?? null;
     if (!nextReplyTo) return;
+    if (editingMessageRef.current) {
+      replaceLocalComposer("");
+      persistDraft("");
+    }
+    setEditingMessage(null);
     setSelectedIdx(index);
     setFollowMessages(index === messages.length - 1);
     setReplyTo(nextReplyTo);
@@ -98,12 +157,58 @@ export function useChatComposerRuntime({
     controller,
     focusInput,
     messages,
+    persistDraft,
+    replaceLocalComposer,
+    setEditingMessage,
     setFollowMessages,
     setReplyTo,
     setSelectedIdx,
     useDefaultControllerChannel,
   ]);
 
+  const beginEditMessage = useCallback((index: number, options?: { deferFocus?: boolean }) => {
+    if (!canSend || index < 0 || index >= messages.length) return false;
+    const message = messages[index] ?? null;
+    if (!message || message.id !== latestEditableMessageId) return false;
+    clearReplyTarget();
+    setEditingMessage(message);
+    setSelectedIdx(index);
+    setFollowMessages(index === messages.length - 1);
+    replaceLocalComposer(message.content);
+    persistDraft(message.content);
+    if (options?.deferFocus) {
+      queueMicrotask(() => focusInput());
+    } else {
+      focusInput();
+    }
+    return true;
+  }, [
+    canSend,
+    clearReplyTarget,
+    focusInput,
+    latestEditableMessageId,
+    messages,
+    persistDraft,
+    replaceLocalComposer,
+    setEditingMessage,
+    setFollowMessages,
+    setSelectedIdx,
+  ]);
+
+  const beginEditLatestMessage = useCallback((options?: { deferFocus?: boolean }) => {
+    if (!latestEditableMessageId) return false;
+    const index = messages.findIndex((message) => message.id === latestEditableMessageId);
+    return beginEditMessage(index, options);
+  }, [beginEditMessage, latestEditableMessageId, messages]);
+
+  const cancelEditMessage = useCallback(() => {
+    if (!editingMessageRef.current) return;
+    setEditingMessage(null);
+    replaceLocalComposer("");
+    persistDraft("");
+    focusInput();
+  }, [focusInput, persistDraft, replaceLocalComposer, setEditingMessage]);
+
   const returnToComposer = useCallback(() => {
     setSelectedIdx(-1);
     setFollowMessages(true);
@@ -113,22 +218,30 @@ export function useChatComposerRuntime({
   }, [canSend, focusInput, setFollowMessages, setSelectedIdx]);
 
   const clearLocalComposer = useCallback(() => {
-    inputValueRef.current = "";
-    updateComposerRows("");
-    const textarea = inputRef.current;
-    if (textarea && textarea.editBuffer.getText() !== "") {
-      applyingExternalDraftRef.current = true;
-      try {
-        textarea.setText("");
-      } finally {
-        applyingExternalDraftRef.current = false;
-      }
-    }
-  }, [applyingExternalDraftRef, inputRef, inputValueRef, updateComposerRows]);
+    replaceLocalComposer("");
+  }, [replaceLocalComposer]);
 
   const sendMessage = useCallback(() => {
     const content = inputValueRef.current.trim();
     if (!content) return;
+    const editing = editingMessageRef.current;
+    if (editing) {
+      if (editSubmittingRef.current) return;
+      const sendChannelId = useDefaultControllerChannel ? channelId : channelIdRef.current;
+      if (editing.channelId !== sendChannelId) return;
+      editSubmittingRef.current = true;
+      void controller.editChannelMessage(sendChannelId, editing.id, content).then((accepted) => {
+        if (!accepted) return;
+        setEditingMessage(null);
+        clearLocalComposer();
+        persistDraft("");
+        setSelectedIdx(-1);
+        setFollowMessages(true);
+      }).finally(() => {
+        editSubmittingRef.current = false;
+      });
+      return;
+    }
     const composerCommand = parseChatComposerCommand(content);
     if (composerCommand?.kind === "direct") {
       void controller.openDirectChannel({ username: composerCommand.username }).then((channel) => {
@@ -154,9 +267,13 @@ export function useChatComposerRuntime({
       }).catch(() => {});
       return;
     }
+    const sendChannelId = useDefaultControllerChannel ? channelId : channelIdRef.current;
+    const replyToId = replyToRef.current?.channelId === sendChannelId
+      ? replyToRef.current.id
+      : undefined;
     const accepted = useDefaultControllerChannel
-      ? controller.send(content, replyToRef.current?.id)
-      : controller.sendToChannel(channelId, content, replyToRef.current?.id);
+      ? controller.send(content, replyToId)
+      : controller.sendToChannel(sendChannelId, content, replyToId);
     if (!accepted) return;
     clearLocalComposer();
     setSelectedIdx(-1);
@@ -168,7 +285,9 @@ export function useChatComposerRuntime({
     controller,
     inputValueRef,
     onChannelChange,
+    persistDraft,
     setDirectExpanded,
+    setEditingMessage,
     setFollowMessages,
     setSelectedIdx,
     useDefaultControllerChannel,
@@ -178,16 +297,13 @@ export function useChatComposerRuntime({
     if (applyingExternalDraftRef.current) return;
     inputValueRef.current = draft;
     updateComposerRows(draft);
-    if (useDefaultControllerChannel) {
-      controller.setDraft(draft);
-    } else {
-      controller.setChannelDraft(channelId, draft);
-    }
+    persistDraft(draft);
   }, [
     applyingExternalDraftRef,
     channelId,
     controller,
     inputValueRef,
+    persistDraft,
     updateComposerRows,
     useDefaultControllerChannel,
   ]);
@@ -230,18 +346,33 @@ export function useChatComposerRuntime({
     clearReplyTarget();
   }, [canSend, clearReplyTarget, replyTo]);
 
+  useEffect(() => {
+    if (canSend || !editingMessage) return;
+    cancelEditMessage();
+  }, [canSend, cancelEditMessage, editingMessage]);
+
   const replyPreview = replyTo
     ? formatInlinePreview(
       replyTo.content,
       Math.max(contentWidth - ` replying to @${replyTo.user.username}: `.length - COMPOSER_ACTION_WIDTH - 1, 0),
     )
     : "";
-  const inputPlaceholder = replyTo ? `Reply to @${replyTo.user.username}...` : "Type a message...";
+  const editingPreview = editingMessage
+    ? formatInlinePreview(
+      editingMessage.content,
+      Math.max(contentWidth - " editing: ".length - COMPOSER_ACTION_WIDTH - 1, 0),
+    )
+    : "";
+  const inputPlaceholder = editingMessage ? "Edit message..." : replyTo ? `Reply to @${replyTo.user.username}...` : "Type a message...";
 
   return {
+    beginEditLatestMessage,
+    beginEditMessage,
     beginReplyTo,
+    cancelEditMessage,
     clearReplyTarget,
     commitLocalDraft,
+    editingPreview,
     focusComposer,
     inputPlaceholder,
     replyPreview,

package/src/plugins/builtin/chat/content/composer.tsx

@@ -14,6 +14,7 @@ interface MutableRef<T> {
 
 interface ChatComposerAreaProps {
   canSend: boolean;
+  cancelEditMessage: () => void;
   clearReplyTarget: () => void;
   commitLocalDraft: (draft: string) => void;
   composerHeight: number;
@@ -27,6 +28,8 @@ interface ChatComposerAreaProps {
   inputRef: MutableRef<TextareaRenderable | null>;
   inputValueRef: MutableRef<string>;
   nativePaneChrome: boolean | undefined;
+  editingMessage: ChatMessage | null;
+  editingPreview: string;
   replyPreview: string;
   replyTo: ChatMessage | null;
   sendMessage: () => void;
@@ -35,6 +38,7 @@ interface ChatComposerAreaProps {
 
 export function ChatComposerArea({
   canSend,
+  cancelEditMessage,
   clearReplyTarget,
   commitLocalDraft,
   composerHeight,
@@ -48,6 +52,8 @@ export function ChatComposerArea({
   inputRef,
   inputValueRef,
   nativePaneChrome,
+  editingMessage,
+  editingPreview,
   replyPreview,
   replyTo,
   sendMessage,
@@ -89,7 +95,20 @@ export function ChatComposerArea({
         />
       )}
 
-      {replyTo && (
+      {editingMessage && (
+        <Box height={1} width={contentWidth} flexDirection="row">
+          <Text fg={colors.textMuted}> editing </Text>
+          <Text fg={colors.textDim}>{editingPreview ? `: ${editingPreview}` : ""}</Text>
+          <Box flexGrow={1} />
+          <ChatActionChip
+            label="Cancel"
+            width={COMPOSER_ACTION_WIDTH}
+            onPress={cancelEditMessage}
+          />
+        </Box>
+      )}
+
+      {!editingMessage && replyTo && (
         <Box height={1} width={contentWidth} flexDirection="row">
           <Text fg={colors.textMuted}> replying to </Text>
           <Text fg={colors.positive} attributes={TextAttributes.BOLD}>{`@${replyTo.user.username}`}</Text>
@@ -135,14 +154,16 @@ export function ChatComposerArea({
 export function getChatComposerAreaHeight({
   canSend,
   composerHeight,
+  editingMessage,
   nativePaneChrome,
   replyTo,
 }: {
   canSend: boolean;
   composerHeight: number;
+  editingMessage: ChatMessage | null;
   nativePaneChrome: boolean | undefined;
   replyTo: ChatMessage | null;
 }) {
   if (!canSend) return 2;
-  return getMessageComposerBlockHeight({ height: composerHeight, nativePaneChrome }) + (replyTo ? 1 : 0);
+  return getMessageComposerBlockHeight({ height: composerHeight, nativePaneChrome }) + (editingMessage || replyTo ? 1 : 0);
 }