gloomberb 0.8.1 → 0.9.0

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}

package/src/plugins/builtin/chat/message/desktop.tsx

@@ -22,14 +22,20 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
   onUserHover,
   onUserHoverEnd,
   beginReplyTo,
+  beginEditMessage,
   jumpToMessage,
+  latestEditableMessageId,
   registerMessageElement,
 }: ChatMessageBaseProps & {
   registerMessageElement: (messageId: string, node: unknown | null) => void;
 }) {
   const state = getChatMessageRenderState({ msg, index, messages, selectedIdx, hoveredIdx, canSend });
+  const canEditMessage = msg.id === latestEditableMessageId;
   const showInlineReplyAction = !state.grouped && canSend;
+  const showInlineEditAction = !state.grouped && canSend && canEditMessage;
   const showGroupedReplyAction = state.grouped && canSend;
+  const showGroupedEditAction = state.grouped && canSend && canEditMessage;
+  const groupedActionWidth = MESSAGE_ACTION_WIDTH * Number(showGroupedReplyAction) + MESSAGE_ACTION_WIDTH * Number(showGroupedEditAction);
   const rowProps = {
     width: "100%",
     paddingRight: DESKTOP_MESSAGE_RIGHT_PADDING,
@@ -98,21 +104,37 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
             {msg.user.username ?? "anon"}
           </Text>
           <Text fg={state.headerStatusColor}> {state.headerStatus}</Text>
-          {showInlineReplyAction && (
+          {(showInlineReplyAction || showInlineEditAction) && (
             <>
               <Text fg={state.headerStatusColor}> </Text>
-              <Box
-                width={MESSAGE_ACTION_WIDTH}
-                height={1}
-                data-gloom-role="chat-message-reply-action"
-              >
-                <ChatActionChip
-                  label="Reply"
+              {showInlineReplyAction && (
+                <Box
+                  width={MESSAGE_ACTION_WIDTH}
+                  height={1}
+                  data-gloom-role="chat-message-reply-action"
+                >
+                  <ChatActionChip
+                    label="Reply"
+                    width={MESSAGE_ACTION_WIDTH}
+                    emphasized={state.isSelected}
+                    onPress={() => beginReplyTo(index)}
+                  />
+                </Box>
+              )}
+              {showInlineEditAction && (
+                <Box
                   width={MESSAGE_ACTION_WIDTH}
-                  emphasized={state.isSelected}
-                  onPress={() => beginReplyTo(index)}
-                />
-              </Box>
+                  height={1}
+                  data-gloom-role="chat-message-reply-action"
+                >
+                  <ChatActionChip
+                    label="Edit"
+                    width={MESSAGE_ACTION_WIDTH}
+                    emphasized={state.isSelected}
+                    onPress={() => beginEditMessage(index)}
+                  />
+                </Box>
+              )}
             </>
           )}
         </Box>
@@ -135,21 +157,32 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
             onUserHoverEnd={onUserHoverEnd}
           />
         </Box>
-        {showGroupedReplyAction && (
+        {(showGroupedReplyAction || showGroupedEditAction) && (
           <Box
             position="absolute"
             top={0}
             right={0}
-            width={MESSAGE_ACTION_WIDTH}
+            width={groupedActionWidth}
             height={1}
+            flexDirection="row"
             data-gloom-role="chat-message-reply-action"
           >
-            <ChatActionChip
-              label="Reply"
-              width={MESSAGE_ACTION_WIDTH}
-              emphasized={state.isSelected}
-              onPress={() => beginReplyTo(index)}
-            />
+            {showGroupedReplyAction && (
+              <ChatActionChip
+                label="Reply"
+                width={MESSAGE_ACTION_WIDTH}
+                emphasized={state.isSelected}
+                onPress={() => beginReplyTo(index)}
+              />
+            )}
+            {showGroupedEditAction && (
+              <ChatActionChip
+                label="Edit"
+                width={MESSAGE_ACTION_WIDTH}
+                emphasized={state.isSelected}
+                onPress={() => beginEditMessage(index)}
+              />
+            )}
           </Box>
         )}
       </Box>

package/src/plugins/builtin/chat/message/inline-tokens.tsx

@@ -6,10 +6,12 @@ import { TickerBadge } from "../../../../components/ticker/badge";
 import type { InlineTickerCatalogEntry } from "../../../../state/hooks/inline-tickers";
 import { blendHex, colors } from "../../../../theme/colors";
 import type { ChatUserSummary } from "../../../../api-client";
-import { tokenizeInlineContent } from "../../../../utils/inline-content-tokenizer";
+import { tokenizeInlineContent, type InlineContentToken } from "../../../../utils/inline-content-tokenizer";
 
 export function ResponsiveTickerBadgeText({
-  text,
+  text = "",
+  tokens: providedTokens,
+  prewrapped = false,
   catalog,
   textColor,
   openTicker,
@@ -17,7 +19,9 @@ export function ResponsiveTickerBadgeText({
   onUserHover,
   onUserHoverEnd,
 }: {
-  text: string;
+  text?: string;
+  tokens?: readonly InlineContentToken[];
+  prewrapped?: boolean;
   catalog: Record<string, InlineTickerCatalogEntry>;
   textColor: string;
   openTicker: (symbol: string) => void;
@@ -26,19 +30,21 @@ export function ResponsiveTickerBadgeText({
   onUserHoverEnd?: () => void;
 }) {
   const [hoveredSymbol, setHoveredSymbol] = useState<string | null>(null);
-  const tokens = useMemo(() => tokenizeInlineContent(text), [text]);
+  const tokens = useMemo(() => providedTokens ?? tokenizeInlineContent(text), [providedTokens, text]);
   const renderTextToken = (value: string, tokenIndex: number) => {
     if (!value) return null;
     return (
       <Text
         key={`text:${tokenIndex}`}
         fg={textColor}
-        wrapText
-        style={{
-          minWidth: 0,
-          whiteSpace: "pre-wrap",
-          overflowWrap: "anywhere",
-        }}
+        wrapText={!prewrapped}
+        style={prewrapped
+          ? undefined
+          : {
+            minWidth: 0,
+            whiteSpace: "pre-wrap",
+            overflowWrap: "anywhere",
+          }}
       >
         {value}
       </Text>

package/src/plugins/builtin/chat/message/render-state.ts

@@ -41,7 +41,11 @@ export function getChatMessageRenderState({
   const isSending = msg.clientStatus === "sending";
   const hasFailed = msg.clientStatus === "failed";
   const selectedTextColor = hasFailed ? colors.negative : colors.selectedText;
-  const headerStatus = isSending ? "sending..." : hasFailed ? "failed" : formatTimeAgo(msg.createdAt);
+  const headerStatus = isSending
+    ? "sending..."
+    : hasFailed
+      ? "failed"
+      : `${formatTimeAgo(msg.createdAt)}${msg.editedAt ? " edited" : ""}`;
 
   return {
     isSelected,