gloomberb 0.8.1 → 0.8.2

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

@@ -42,6 +42,10 @@ import {
 import {
   handleChatNotification as handleChatNotificationEvent,
 } from "./notifications";
+import {
+  CHAT_MESSAGE_EDIT_WINDOW_LABEL,
+  isWithinChatMessageEditWindow,
+} from "../edit-window";
 import { ChatControllerRealtime } from "./realtime";
 import { ChatControllerChannels } from "./channels";
 import { ChatControllerView } from "./view";
@@ -367,6 +371,42 @@ export class ChatController {
     });
   }
 
+  async editChannelMessage(channelId: string, messageId: string, content: string): Promise<boolean> {
+    const normalizedChannelId = normalizeChannelId(channelId);
+    const channel = this.ensureChannelState(normalizedChannelId);
+    const messageContent = content.trim();
+    if (!messageContent) return false;
+    if (!this.session.user?.emailVerified || !this.session.sessionToken) return false;
+
+    const latestOwnMessage = [...getVisibleMessages(channel)]
+      .reverse()
+      .find((message) => (
+        message.user.id === this.session.user?.id
+        && !message.clientStatus
+      ));
+    if (!latestOwnMessage || latestOwnMessage.id !== messageId) {
+      this.notifyFn({ body: "Only your latest sent message can be edited.", type: "error" });
+      return false;
+    }
+    if (!isWithinChatMessageEditWindow(latestOwnMessage)) {
+      this.notifyFn({ body: `Messages can only be edited within ${CHAT_MESSAGE_EDIT_WINDOW_LABEL}.`, type: "error" });
+      return false;
+    }
+    if (latestOwnMessage.content === messageContent) return true;
+
+    try {
+      const message = await apiClient.editMessage(normalizedChannelId, messageId, messageContent);
+      this.mergeMessages(normalizedChannelId, [message]);
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error && error.message
+        ? error.message
+        : "Failed to edit message.";
+      this.notifyFn({ body: errorMessage, type: "error" });
+      return false;
+    }
+  }
+
   ensureConnection(channelId = DEFAULT_CHAT_CHANNEL_ID): void {
     const normalizedChannelId = normalizeChannelId(channelId);
     const channel = this.ensureChannelState(normalizedChannelId);
@@ -451,6 +491,7 @@ export class ChatController {
       options,
       ensureChannelState: (channelId) => this.ensureChannelState(channelId),
       mergeMessages: (channelId, messages, mergeOptions) => this.mergeMessages(channelId, messages, mergeOptions),
+      getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
       notifiedMessageIds: this.notifiedMessageIds,
       notify: this.notifyFn,
     });

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

@@ -30,6 +30,24 @@ function mergeStoredMessages(channel: ChannelRuntimeState, messages: ChatMessage
     }
     merged.set(message.id, message);
   }
+  for (const message of messages) {
+    for (const [id, current] of merged) {
+      if (current.replyToId !== message.id || current.replyTo?.content === message.content) continue;
+      merged.set(id, {
+        ...current,
+        replyTo: current.replyTo
+          ? {
+            ...current.replyTo,
+            content: message.content,
+            user: {
+              id: message.user.id,
+              username: message.user.username ?? current.replyTo.user.username,
+            },
+          }
+          : current.replyTo,
+      });
+    }
+  }
   channel.messages = [...merged.values()]
     .sort(compareMessages);
   channel.lastCursor = channel.messages[channel.messages.length - 1]?.id ?? channel.lastCursor;

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

@@ -1,6 +1,7 @@
 import type { AppNotificationRequest } from "../../../../types/plugin";
-import { apiClient, type ChatMessage, type ChatNotification } from "../../../../api-client";
+import { apiClient, type ChatChannel, type ChatMessage, type ChatNotification } from "../../../../api-client";
 import type { ChannelRuntimeState, MergeMessagesOptions } from "./state";
+import { formatChatPaneTitle } from "../channel-labels";
 import {
   formatChannelToast,
   formatMentionToast,
@@ -9,23 +10,26 @@ import {
 
 function notifyChatServerMessage({
   notification,
+  channel,
   notifiedMessageIds,
   notify,
 }: {
   notification: ChatNotification;
+  channel: ChatChannel | undefined;
   notifiedMessageIds: Set<string>;
   notify: (notification: AppNotificationRequest) => void;
 }): void {
   if (notifiedMessageIds.has(notification.messageId)) return;
   notifiedMessageIds.add(notification.messageId);
+  const channelTitle = formatChatPaneTitle(channel, notification.channelId);
   const body = notification.type === "reply"
     ? formatReplyToast(notification.message)
     : notification.type === "mention"
       ? formatMentionToast(notification.message)
-      : formatChannelToast(notification.channelId, notification.message);
+      : formatChannelToast(channelTitle, notification.message, channel?.kind);
   notify({
     title: "Gloomberb chat",
-    subtitle: `#${notification.channelId}`,
+    subtitle: channelTitle,
     body,
     type: "info",
     desktop: "when-inactive",
@@ -37,6 +41,7 @@ export function handleChatNotification({
   options = {},
   ensureChannelState,
   mergeMessages,
+  getChannel,
   notifiedMessageIds,
   notify,
 }: {
@@ -44,13 +49,14 @@ export function handleChatNotification({
   options?: { countUnread?: boolean };
   ensureChannelState: (channelId: string) => ChannelRuntimeState;
   mergeMessages: (channelId: string, messages: ChatMessage[], options?: MergeMessagesOptions) => void;
+  getChannel: (channelId: string) => ChatChannel | undefined;
   notifiedMessageIds: Set<string>;
   notify: (notification: AppNotificationRequest) => void;
 }): void {
   mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
   const channel = ensureChannelState(notification.channelId);
   if (channel.openViewCount === 0) {
-    notifyChatServerMessage({ notification, notifiedMessageIds, notify });
+    notifyChatServerMessage({ notification, channel: getChannel(notification.channelId), notifiedMessageIds, notify });
   }
   void apiClient.markChatNotificationsDelivered([notification.id]).catch(() => {});
 }

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

@@ -1,4 +1,4 @@
-import type { ChatMessage } from "../../../../api-client";
+import type { ChatChannel, ChatMessage } from "../../../../api-client";
 
 const ISO_TIMESTAMP_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
 const USERNAME_MENTION = /(^|[^A-Za-z0-9_])@([A-Za-z][A-Za-z0-9_]{2,29})(?![A-Za-z0-9_])/g;
@@ -42,10 +42,13 @@ export function formatReplyToast(message: ChatMessage): string {
   return `@${author} replied to you: ${snippet}`;
 }
 
-export function formatChannelToast(channelId: string, message: ChatMessage): string {
+export function formatChannelToast(channelTitle: string, message: ChatMessage, channelKind?: ChatChannel["kind"]): string {
   const author = message.user.username || "Someone";
   const snippet = formatMessageSnippet(message.content);
-  return snippet ? `#${channelId} @${author}: ${snippet}` : `#${channelId} @${author} sent a message.`;
+  if (channelKind === "direct") {
+    return snippet ? `@${author}: ${snippet}` : `@${author} sent a message.`;
+  }
+  return snippet ? `${channelTitle} @${author}: ${snippet}` : `${channelTitle} @${author} sent a message.`;
 }
 
 export function isLegacyTimestampCursor(cursor: string | null): boolean {

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

@@ -80,7 +80,7 @@ export class ChatControllerView {
 
   emit(channelId?: string): void {
     for (const entry of this.listeners) {
-      if (channelId && entry.channelId !== channelId) continue;
+      if (channelId && entry.channelId !== channelId && entry.channelId !== DEFAULT_CHAT_CHANNEL_ID) continue;
       const snapshot = this.options.getListenerSnapshot(entry.channelId);
       try {
         entry.listener(snapshot);

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

@@ -18,6 +18,7 @@ const originalUpdateChatChannelState = apiClient.updateChatChannelState.bind(api
 const originalMarkChatNotificationsDelivered = apiClient.markChatNotificationsDelivered.bind(apiClient);
 const originalSubscribeChatNotifications = apiClient.subscribeChatNotifications.bind(apiClient);
 const originalSubscribeChatPresence = apiClient.subscribeChatPresence.bind(apiClient);
+const originalEditMessage = apiClient.editMessage.bind(apiClient);
 
 const SERVER_CHAT_CHANNELS: ChatChannel[] = [
   { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
@@ -31,6 +32,10 @@ async function flushMicrotasks() {
   await Promise.resolve();
 }
 
+function recentChatTimestamp(offsetMs = 60_000) {
+  return new Date(Date.now() - offsetMs).toISOString();
+}
+
 class TrackingPersistence extends MemoryPersistence {
   stateWrites = 0;
 
@@ -77,6 +82,7 @@ afterEach(() => {
   apiClient.markChatNotificationsDelivered = originalMarkChatNotificationsDelivered;
   apiClient.subscribeChatNotifications = originalSubscribeChatNotifications;
   apiClient.subscribeChatPresence = originalSubscribeChatPresence;
+  apiClient.editMessage = originalEditMessage;
 });
 
 describe("ChatController", () => {
@@ -717,6 +723,130 @@ describe("ChatController", () => {
     detachSecondView();
   });
 
+  test("edits the latest message from the current user", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const original: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "helo",
+      replyToId: null,
+      createdAt: recentChatTimestamp(),
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [original],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+    controller.attachPersistence(persistence);
+    apiClient.editMessage = async (channelId, messageId, content) => ({
+      ...original,
+      channelId,
+      id: messageId,
+      content,
+      editedAt: "2026-03-28T00:01:00.000Z",
+    });
+
+    await expect(controller.editChannelMessage("everyone", "m1", "hello")).resolves.toBe(true);
+
+    const [edited] = controller.getSnapshot().messages;
+    expect(edited).toMatchObject({
+      id: "m1",
+      content: "hello",
+      editedAt: "2026-03-28T00:01:00.000Z",
+    });
+  });
+
+  test("refuses to edit after the edit window expires", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const original: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "old typo",
+      replyToId: null,
+      createdAt: recentChatTimestamp(16 * 60_000),
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [original],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+    controller.setNotifier((notification) => notifications.push(notification));
+    controller.attachPersistence(persistence);
+    apiClient.editMessage = async () => {
+      throw new Error("should not call server");
+    };
+
+    await expect(controller.editChannelMessage("everyone", "m1", "old fix")).resolves.toBe(false);
+
+    expect(controller.getSnapshot().messages[0]?.content).toBe("old typo");
+    expect(notifications).toEqual([{ body: "Messages can only be edited within 15 minutes.", type: "error" }]);
+  });
+
+  test("refuses to edit an older message from the current user", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const messages: ChatMessage[] = [
+      {
+        id: "m1",
+        channelId: "everyone",
+        content: "older",
+        replyToId: null,
+        createdAt: "2026-03-28T00:00:00.000Z",
+        user: { id: "u1", username: "vince", displayName: "Vince" },
+      },
+      {
+        id: "m2",
+        channelId: "everyone",
+        content: "newer",
+        replyToId: null,
+        createdAt: "2026-03-28T00:01:00.000Z",
+        user: { id: "u1", username: "vince", displayName: "Vince" },
+      },
+    ];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages,
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+    controller.setNotifier((notification) => notifications.push(notification));
+    controller.attachPersistence(persistence);
+    apiClient.editMessage = async () => {
+      throw new Error("should not call server");
+    };
+
+    await expect(controller.editChannelMessage("everyone", "m1", "edited")).resolves.toBe(false);
+
+    expect(controller.getSnapshot().messages.map((message) => message.content)).toEqual(["older", "newer"]);
+    expect(notifications).toEqual([{ body: "Only your latest sent message can be edited.", type: "error" }]);
+  });
+
   test("marks a pending message as failed when sending errors", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -1089,6 +1219,65 @@ describe("ChatController", () => {
     }]);
   });
 
+  test("uses direct channel labels in server-issued notification subtitles", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const notifications: AppNotificationRequest[] = [];
+    const directChannel: ChatChannel = {
+      id: "dm:u2",
+      name: "u2",
+      kind: "direct",
+      created_at: "2026-03-28T00:00:00.000Z",
+      dmUser: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: directChannel.id,
+      content: "ping",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    apiClient.getChatState = async () => ({
+      channels: [...SERVER_CHAT_CHANNELS, directChannel],
+      onlineCount: 0,
+      channelStates: [...SERVER_CHAT_CHANNELS, directChannel].map((channel) => ({
+        channelId: channel.id,
+        notificationsEnabled: false,
+        lastReadMessageId: null,
+        unreadCount: 0,
+      })),
+      notifications: [],
+    });
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+    controller.setNotifier((entry) => {
+      notifications.push(entry);
+    });
+    controller.attachPersistence(persistence);
+    await controller.refreshChatState();
+
+    (controller as any).handleChatNotification({
+      id: "n1",
+      type: "channel",
+      channelId: directChannel.id,
+      messageId: "m1",
+      createdAt: "2026-03-28T00:00:00.000Z",
+      message,
+    } satisfies ChatNotification);
+
+    expect(notifications).toEqual([{
+      title: "Gloomberb chat",
+      subtitle: "@bob",
+      body: "@bob: ping",
+      type: "info",
+      desktop: "when-inactive",
+    }]);
+  });
+
   test("tracks unread channel messages and clears them when the channel opens", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();

package/src/plugins/builtin/chat/edit-window.ts

@@ -0,0 +1,24 @@
+import type { ChatMessage } from "../../../api-client";
+
+export const CHAT_MESSAGE_EDIT_WINDOW_MS = 15 * 60_000;
+export const CHAT_MESSAGE_EDIT_WINDOW_LABEL = "15 minutes";
+
+export function isWithinChatMessageEditWindow(message: ChatMessage, nowMs = Date.now()): boolean {
+  const createdMs = Date.parse(message.createdAt);
+  return Number.isFinite(createdMs) && nowMs - createdMs <= CHAT_MESSAGE_EDIT_WINDOW_MS;
+}
+
+export function findLatestEditableChatMessage(
+  messages: ChatMessage[],
+  userId: string | null | undefined,
+  nowMs = Date.now(),
+): ChatMessage | null {
+  if (!userId) return null;
+  return [...messages]
+    .reverse()
+    .find((message) => (
+      message.user.id === userId
+      && !message.clientStatus
+      && isWithinChatMessageEditWindow(message, nowMs)
+    )) ?? null;
+}

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

@@ -30,6 +30,10 @@ export function formatInlinePreview(text: string, width: number) {
   return truncateWithEllipsis(normalizeInlinePreview(text), width);
 }
 
+export type ChatBodyInlineToken = InlineContentToken;
+
+export type ChatBodyLine = ChatBodyInlineToken[];
+
 function wrapTextLines(text: string, width: number) {
   const safeWidth = Math.max(width, 1);
   const lines: string[] = [];
@@ -78,52 +82,108 @@ function inlineTokenWidth(
   return Math.max(baseWidth, hoverWidth);
 }
 
+function tokenWithValue(token: InlineContentToken, value: string): InlineContentToken {
+  if (token.kind === "link") return { ...token, value };
+  if (token.kind === "username") return { ...token, value };
+  if (token.kind === "ticker") return { ...token, value };
+  return { kind: "text", value };
+}
+
+function firstDisplayWidthChunk(value: string, width: number): string {
+  return splitLongTextSegmentByDisplayWidth(value, Math.max(width, 1))[0] ?? "";
+}
+
+function trimLineEnd(line: ChatBodyLine): ChatBodyLine {
+  const next = [...line];
+  while (next.length > 0) {
+    const last = next[next.length - 1]!;
+    if (last.kind !== "text") break;
+    const trimmed = last.value.trimEnd();
+    if (trimmed) {
+      next[next.length - 1] = { ...last, value: trimmed };
+      break;
+    }
+    next.pop();
+  }
+  return next;
+}
+
 function wrapInlineContentLine(
   text: string,
   width: number,
   catalog: Record<string, InlineTickerCatalogEntry>,
-): string[] {
+): ChatBodyLine[] {
   const safeWidth = Math.max(width, 1);
-  const lines: string[] = [];
-  let current = "";
+  const lines: ChatBodyLine[] = [];
+  let current: ChatBodyLine = [];
   let currentWidth = 0;
 
   const finishLine = () => {
-    lines.push(current.trimEnd());
-    current = "";
+    lines.push(trimLineEnd(current));
+    current = [];
     currentWidth = 0;
   };
 
-  const appendTextPart = (rawPart: string) => {
-    let part = currentWidth === 0 ? rawPart.trimStart() : rawPart;
-    if (!part) return;
-
-    while (part) {
-      const partWidth = displayWidth(part);
-      if (currentWidth > 0 && currentWidth + partWidth > safeWidth) {
+  const appendSegment = (token: InlineContentToken, rawValue: string, trimStartOnWrap: boolean) => {
+    let value = currentWidth === 0 && trimStartOnWrap ? rawValue.trimStart() : rawValue;
+    if (!value) return;
+
+    while (value) {
+      const tokenWidth = token.kind === "ticker"
+        ? inlineTokenWidth(tokenWithValue(token, value), catalog)
+        : displayWidth(value);
+      const available = safeWidth - currentWidth;
+
+      if (currentWidth > 0 && tokenWidth > available) {
+        if (available <= 0) {
+          finishLine();
+          if (trimStartOnWrap) value = value.trimStart();
+          continue;
+        }
+
+        if (token.kind === "ticker") {
+          finishLine();
+          continue;
+        }
+
+        const chunk = firstDisplayWidthChunk(value, Math.max(available, 1));
+        if (chunk) {
+          current.push(tokenWithValue(token, chunk));
+          currentWidth += displayWidth(chunk);
+          value = value.slice(chunk.length);
+        }
         finishLine();
-        part = part.trimStart();
-        if (!part) return;
+        if (trimStartOnWrap) value = value.trimStart();
         continue;
       }
 
-      if (partWidth <= safeWidth - currentWidth) {
-        current += part;
-        currentWidth += partWidth;
+      if (tokenWidth <= safeWidth - currentWidth || token.kind === "ticker") {
+        current.push(tokenWithValue(token, value));
+        currentWidth += tokenWidth;
         return;
       }
 
-      const available = Math.max(safeWidth - currentWidth, 1);
-      const [chunk = "", ...rest] = splitLongTextSegmentByDisplayWidth(part, available);
+      const chunk = firstDisplayWidthChunk(value, Math.max(safeWidth - currentWidth, 1));
       if (chunk) {
-        current += chunk;
+        current.push(tokenWithValue(token, chunk));
         currentWidth += displayWidth(chunk);
+        value = value.slice(chunk.length);
       }
       finishLine();
-      part = rest.join("").trimStart();
+      if (trimStartOnWrap) value = value.trimStart();
     }
   };
 
+  const appendTextPart = (rawPart: string) => {
+    let part = rawPart;
+    const partWidth = displayWidth(part);
+    if (currentWidth > 0 && partWidth > safeWidth - currentWidth && partWidth <= safeWidth) {
+      finishLine();
+      part = part.trimStart();
+    }
+    appendSegment({ kind: "text", value: part }, part, true);
+  };
+
   const appendText = (value: string) => {
     const parts = value.match(/\S+\s*|\s+/g) ?? [value];
     for (const part of parts) {
@@ -134,8 +194,7 @@ function wrapInlineContentLine(
   const appendInlineToken = (token: InlineContentToken) => {
     const tokenWidth = inlineTokenWidth(token, catalog);
     if (currentWidth > 0 && currentWidth + tokenWidth > safeWidth) finishLine();
-    current += token.value;
-    currentWidth += tokenWidth;
+    appendSegment(token, token.value, false);
   };
 
   for (const token of tokenizeInlineContent(text)) {
@@ -146,24 +205,24 @@ function wrapInlineContentLine(
     appendInlineToken(token);
   }
 
-  if (current || lines.length === 0) lines.push(current.trimEnd());
+  if (current.length > 0 || lines.length === 0) lines.push(trimLineEnd(current));
   return lines;
 }
 
-function wrapInlineContentLines(
+export function getMessageBodyTokenLines(
   text: string,
   width: number,
   catalog: Record<string, InlineTickerCatalogEntry>,
-): string[] {
-  const lines: string[] = [];
+): ChatBodyLine[] {
+  const lines: ChatBodyLine[] = [];
   for (const paragraph of text.split("\n")) {
     if (!paragraph) {
-      lines.push("");
+      lines.push([]);
       continue;
     }
     lines.push(...wrapInlineContentLine(paragraph, width, catalog));
   }
-  return lines.length > 0 ? lines : [""];
+  return lines.length > 0 ? lines : [[]];
 }
 
 export function getMessageBodyLines(
@@ -172,7 +231,7 @@ export function getMessageBodyLines(
   catalog?: Record<string, InlineTickerCatalogEntry>,
 ) {
   const contentLineWidth = Math.max(width - 4, 1);
-  if (catalog) return wrapInlineContentLines(message.content, contentLineWidth, catalog);
+  if (catalog) return getMessageBodyTokenLines(message.content, contentLineWidth, catalog).map((line) => line.map((token) => token.value).join(""));
   return wrapTextLines(message.content, contentLineWidth);
 }
 
@@ -183,7 +242,11 @@ export function estimateMessageHeight(
   catalog?: Record<string, InlineTickerCatalogEntry>,
 ) {
   const headerHeight = grouped ? 0 : 1;
-  return headerHeight + (message.replyTo ? 1 : 0) + getMessageBodyLines(message, width, catalog).length;
+  const contentLineWidth = Math.max(width - 4, 1);
+  const bodyLineCount = catalog
+    ? getMessageBodyTokenLines(message.content, contentLineWidth, catalog).length
+    : getMessageBodyLines(message, width, catalog).length;
+  return headerHeight + (message.replyTo ? 1 : 0) + bodyLineCount;
 }
 
 export function estimateComposerHeight(text: string, width: number) {

package/src/plugins/builtin/chat/message/action-chip.tsx

@@ -25,6 +25,7 @@ export function ChatActionChip({
       height={1}
       backgroundColor={emphasized ? colors.borderFocused : colors.panel}
       onMouseDown={handlePress}
+      style={{ cursor: "pointer" }}
     >
       <Text
         fg={emphasized ? colors.bg : colors.text}