gloomberb 0.16.3 → 0.16.4

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

@@ -57,6 +57,8 @@ import {
 } from "./notifications";
 import {
   CHAT_MESSAGE_EDIT_WINDOW_LABEL,
+  DISCORD_MESSAGE_EDIT_NOTICE,
+  isEditableOnGloom,
   isWithinChatMessageEditWindow,
 } from "../edit-window";
 import { ChatControllerRealtime } from "./realtime";
@@ -65,6 +67,7 @@ import { ChatControllerView } from "./view";
 import { ChatControllerMessageLoading } from "./message-loading";
 import { ChatControllerStorage } from "./storage";
 import { listUnreadInboxItems } from "../unread-inbox";
+import type { ChatConversationList } from "../conversations";
 import {
   applySignedOutChatControllerSession,
   createChatControllerSessionState,
@@ -75,6 +78,26 @@ import {
 const chatLog = debugLog.createLogger("chat-controller");
 const IMAGE_LINK_REFRESH_INTERVAL_MS = 60_000;
 
+function timeOf(value: string | undefined): number {
+  const time = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(time) ? time : Number.NEGATIVE_INFINITY;
+}
+
+/**
+ * The newest message held for a conversation, sent or received. A DM or group
+ * with nothing on this device yet counts from when it was started.
+ */
+function lastConversationActivity(channel: ChatChannel, state: ChannelRuntimeState | undefined): number {
+  const started = channel.kind === "direct" || channel.kind === "group"
+    ? timeOf(channel.created_at)
+    : Number.NEGATIVE_INFINITY;
+  return Math.max(
+    started,
+    timeOf(state?.messages.at(-1)?.createdAt),
+    timeOf(state?.pendingMessages.at(-1)?.createdAt),
+  );
+}
+
 export type { ChatControllerSnapshot } from "./state";
 
 export class ChatController {
@@ -186,6 +209,27 @@ export class ChatController {
     });
   }
 
+  /**
+   * Every conversation the Chat sidebar lists, with its unread count and last
+   * activity, from what this device already holds; no request. Null until a
+   * verified account is signed in.
+   */
+  listConversations(): ChatConversationList | null {
+    const user = this.session.user;
+    if (!user?.emailVerified) return null;
+    return {
+      userId: user.id,
+      states: this.channelCatalog.getChannels().map((channel) => {
+        const state = this.storage.channelStates.get(channel.id);
+        return {
+          channel,
+          unreadCount: Math.max(0, state?.unreadCount ?? 0),
+          lastActivityAt: lastConversationActivity(channel, state),
+        };
+      }),
+    };
+  }
+
   getChannels(): ChatChannel[] {
     return this.channelCatalog.getChannels();
   }
@@ -558,6 +602,10 @@ export class ChatController {
       this.notifyFn({ body: "Only your latest sent message can be edited.", type: "error" });
       return false;
     }
+    if (!isEditableOnGloom(latestOwnMessage)) {
+      this.notifyFn({ body: DISCORD_MESSAGE_EDIT_NOTICE, 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;

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

@@ -0,0 +1,256 @@
+import type { ChatChannel, ChatUserSummary } from "../../../api-client";
+import { teamStore } from "../cloud/team/store";
+import { formatChatPaneTitle } from "./channel-labels";
+
+/** What the chat controller holds about one conversation, read without a request. */
+export interface ChatConversationState {
+  channel: ChatChannel;
+  unreadCount: number;
+  /** Newest message on this device, or when a DM started; -Infinity when unknown. */
+  lastActivityAt: number;
+}
+
+/** The signed-in account and its conversations, as the chat controller holds them. */
+export interface ChatConversationList {
+  userId: string;
+  states: ChatConversationState[];
+}
+
+export type ChatConversationKind = "channel" | "team" | "direct" | "group";
+
+export interface ChatConversation {
+  channelId: string;
+  kind: ChatConversationKind;
+  /** As the Chat pane titles it: #general, MD·#general, @alice, a group's name. */
+  title: string;
+  /** Muted beside the title: a DM's full name, a group's members, a channel's team. */
+  name: string | null;
+  /** The other person's username in a DM, lower case. */
+  username: string | null;
+  unreadCount: number;
+  lastActivityAt: number;
+  /** Position in the Chat sidebar: channels, then team channels, then DMs. */
+  order: number;
+  /** What the conversation is called, lower case: channel, username, full name, group name. */
+  names: string[];
+  /** Every word a typed word may start, lower case. */
+  words: string[];
+}
+
+/** The empty bar is a browse list of everything; chat gets a few rows of it. */
+const EMPTY_QUERY_CONVERSATION_LIMIT = 4;
+/** Typing "messages" or "chat" asks for the list itself, so it gets more. */
+const LISTING_CONVERSATION_LIMIT = 15;
+const SEARCH_CONVERSATION_LIMIT = 8;
+/** Below this many characters a match says little, so unread conversations lead. */
+const SHORT_QUERY_LENGTH = 3;
+
+/** Words that, typed alone, ask for the conversations rather than one of them. */
+const LISTING_WORDS = new Set([
+  "chat",
+  "chats",
+  "message",
+  "messages",
+  "conversation",
+  "conversations",
+  "dm",
+  "dms",
+]);
+
+const WORD = /[\p{L}\p{N}]+/gu;
+
+function wordsOf(value: string | null | undefined): string[] {
+  return value?.toLowerCase().match(WORD) ?? [];
+}
+
+/** "Alice  Smith" and "alice smith" are the same name. */
+function nameKey(value: string | null | undefined): string | null {
+  const words = wordsOf(value);
+  return words.length > 0 ? words.join(" ") : null;
+}
+
+function conversationKind(channel: ChatChannel): ChatConversationKind {
+  if (channel.kind === "direct" || channel.kind === "group" || channel.kind === "team") return channel.kind;
+  return "channel";
+}
+
+const KIND_ORDER: Record<ChatConversationKind, number> = { channel: 0, team: 1, direct: 2, group: 2 };
+
+function memberLabel(member: ChatUserSummary): string | null {
+  return member.username ? `@${member.username}` : member.displayName?.trim() || null;
+}
+
+function groupMembers(channel: ChatChannel, userId: string | null): string | null {
+  const members = (channel.members ?? []).filter((member) => member.id !== userId);
+  const labels = members.map(memberLabel).filter((label): label is string => !!label);
+  if (labels.length === 0) return null;
+  const shown = labels.slice(0, 3);
+  return labels.length > shown.length ? `${shown.join(", ")} +${labels.length - shown.length}` : shown.join(", ");
+}
+
+function describe(
+  channel: ChatChannel,
+  userId: string | null,
+): Pick<ChatConversation, "name" | "names" | "words"> & { username?: string | null } {
+  switch (conversationKind(channel)) {
+    case "direct": {
+      const username = channel.dmUser?.username?.trim() || null;
+      const displayName = channel.dmUser?.displayName?.trim() || null;
+      return {
+        // The title is @username when there is one; the full name says who that is.
+        name: username && displayName && nameKey(displayName) !== nameKey(username) ? displayName : null,
+        username: username?.replace(/^@+/, "").toLowerCase() ?? null,
+        names: [nameKey(username), nameKey(displayName)].filter((name): name is string => !!name),
+        words: [...wordsOf(username), ...wordsOf(displayName)],
+      };
+    }
+    case "group": {
+      const members = (channel.members ?? []).filter((member) => member.id !== userId);
+      return {
+        name: groupMembers(channel, userId),
+        names: [nameKey(channel.name)].filter((name): name is string => !!name),
+        words: [
+          ...wordsOf(channel.name),
+          ...members.flatMap((member) => [...wordsOf(member.username), ...wordsOf(member.displayName)]),
+        ],
+      };
+    }
+    case "team": {
+      const team = teamStore.getTeam(channel.teamId ?? null);
+      return {
+        name: team?.name ?? null,
+        names: [nameKey(channel.name)].filter((name): name is string => !!name),
+        words: [
+          ...wordsOf(channel.name),
+          ...wordsOf(team?.name),
+          ...wordsOf(team?.shortName),
+        ],
+      };
+    }
+    default:
+      return {
+        name: null,
+        names: [nameKey(channel.name)].filter((name): name is string => !!name),
+        words: wordsOf(channel.name),
+      };
+  }
+}
+
+/** The conversations the Chat sidebar lists, in its order, each named as the Chat pane names it. */
+export function buildChatConversations(
+  states: readonly ChatConversationState[],
+  userId: string | null = null,
+): ChatConversation[] {
+  return states
+    .map((state, index): ChatConversation => {
+      const kind = conversationKind(state.channel);
+      const { username = null, ...described } = describe(state.channel, userId);
+      return {
+        channelId: state.channel.id,
+        kind,
+        title: formatChatPaneTitle(state.channel, state.channel.id),
+        username,
+        unreadCount: state.unreadCount,
+        lastActivityAt: state.lastActivityAt,
+        order: KIND_ORDER[kind] * 100_000 + index,
+        ...described,
+      };
+    })
+    .sort((left, right) => left.order - right.order);
+}
+
+function isConversationWithPeople(conversation: ChatConversation): boolean {
+  return conversation.kind === "direct" || conversation.kind === "group";
+}
+
+function compareUnreadFirst(left: ChatConversation, right: ChatConversation): number {
+  return Number(right.unreadCount > 0) - Number(left.unreadCount > 0);
+}
+
+/** Newest activity first; two with nothing known tie. */
+function compareActivity(left: ChatConversation, right: ChatConversation): number {
+  const activity = right.lastActivityAt - left.lastActivityAt;
+  return Number.isNaN(activity) ? 0 : activity;
+}
+
+/** Newest activity first; the sidebar's order breaks ties. */
+function compareRecent(left: ChatConversation, right: ChatConversation): number {
+  return compareActivity(left, right) || left.order - right.order;
+}
+
+/**
+ * Unread conversations first, newest then most unread; then DMs and groups by
+ * their last activity; then channels in the sidebar's order.
+ */
+function compareListing(left: ChatConversation, right: ChatConversation): number {
+  const unread = compareUnreadFirst(left, right);
+  if (unread !== 0) return unread;
+  if (left.unreadCount > 0) {
+    return compareActivity(left, right) || right.unreadCount - left.unreadCount || left.order - right.order;
+  }
+  const people = Number(isConversationWithPeople(right)) - Number(isConversationWithPeople(left));
+  if (people !== 0) return people;
+  return isConversationWithPeople(left) ? compareRecent(left, right) : left.order - right.order;
+}
+
+/**
+ * How well typed words name a conversation: 3 when they are its name, 2 when
+ * its name starts with them, 1 when each starts a word of it, 0 otherwise.
+ */
+function rankChatConversation(conversation: ChatConversation, query: string): number {
+  const tokens = wordsOf(query);
+  if (tokens.length === 0) return 0;
+  const phrase = tokens.join(" ");
+  if (conversation.names.includes(phrase)) return 3;
+  if (conversation.names.some((name) => name.startsWith(phrase))) return 2;
+  return tokens.every((token) => conversation.words.some((word) => word.startsWith(token))) ? 1 : 0;
+}
+
+export type ChatConversationQuery =
+  | { kind: "recent" }
+  | { kind: "listing" }
+  | { kind: "search"; text: string };
+
+/**
+ * What the typed text asks for: nothing typed is the recent list, a word like
+ * "messages" or "chat" on its own is the whole list, and "chat gen" searches
+ * for "gen".
+ */
+export function parseChatConversationQuery(query: string): ChatConversationQuery {
+  const trimmed = query.trim();
+  if (!trimmed) return { kind: "recent" };
+  const [first = "", ...rest] = trimmed.split(/\s+/);
+  if (!LISTING_WORDS.has(first.toLowerCase())) return { kind: "search", text: trimmed };
+  return rest.length === 0 ? { kind: "listing" } : { kind: "search", text: rest.join(" ") };
+}
+
+/**
+ * The conversations that answer the text in the command bar, best first.
+ * With nothing typed: unread ones and the latest DMs, a few at most. Short
+ * text puts unread matches first; longer text the closest names.
+ */
+export function selectChatConversations(
+  conversations: readonly ChatConversation[],
+  query: ChatConversationQuery,
+): ChatConversation[] {
+  if (query.kind === "recent") {
+    return conversations
+      .filter((conversation) => conversation.unreadCount > 0 || isConversationWithPeople(conversation))
+      .sort(compareListing)
+      .slice(0, EMPTY_QUERY_CONVERSATION_LIMIT);
+  }
+  if (query.kind === "listing") {
+    return [...conversations].sort(compareListing).slice(0, LISTING_CONVERSATION_LIMIT);
+  }
+  const shortQuery = query.text.replace(/[#@\s]/g, "").length < SHORT_QUERY_LENGTH;
+  return conversations
+    .map((conversation) => ({ conversation, rank: rankChatConversation(conversation, query.text) }))
+    .filter((entry) => entry.rank > 0)
+    .sort((left, right) => {
+      const unread = compareUnreadFirst(left.conversation, right.conversation);
+      if (shortQuery && unread !== 0) return unread;
+      return right.rank - left.rank || unread || compareRecent(left.conversation, right.conversation);
+    })
+    .slice(0, SEARCH_CONVERSATION_LIMIT)
+    .map((entry) => entry.conversation);
+}

package/src/plugins/builtin/chat/discord-command.ts

@@ -0,0 +1,91 @@
+import { apiClient, type ChatDiscordLink } from "../../../api-client";
+import { ApiRequestError } from "../../../api-client/errors";
+import type { AppNotificationRequest } from "../../../types/plugin";
+import type { DiscordComposerCommand } from "./composer-commands";
+
+/**
+ * Where /discord sends someone to connect. The approval has to happen in a
+ * browser that is signed in to gloom.sh as the same account, which a terminal
+ * user's often is not, so the page handles the web sign-in and then starts the
+ * Discord authorization itself.
+ */
+export const DISCORD_LINK_URL = "https://gloom.sh/discord/link";
+
+/** The Discord calls the composer's /discord command makes. */
+export interface DiscordCommandApi {
+  getLink(): Promise<ChatDiscordLink>;
+  unlink(): Promise<void>;
+  setMirror(enabled: boolean): Promise<void>;
+}
+
+const discordCommandApi: DiscordCommandApi = {
+  getLink: () => apiClient.getChatDiscordLink(),
+  unlink: () => apiClient.unlinkChatDiscord(),
+  setMirror: (enabled) => apiClient.setChatDiscordMirror(enabled),
+};
+
+export const DISCORD_UNAVAILABLE = "Discord sync is not available yet";
+const DISCORD_USAGE = "Use /discord to connect, /discord unlink, or /discord mirror on|off";
+
+type DiscordCommandOutcome = Pick<AppNotificationRequest, "body" | "type">;
+
+/** A server without Discord sync answers its routes with 404, or 501 where it knows them but has no bridge. */
+function isUnavailable(error: unknown): boolean {
+  return error instanceof ApiRequestError && (error.status === 404 || error.status === 501);
+}
+
+function linkedStatus(link: ChatDiscordLink): string {
+  const name = link.discordUsername ? `Linked as ${link.discordUsername}` : "Linked to Discord";
+  const mirror = link.mirror ? "Mirroring is on" : "Mirroring is off";
+  return `${name}. ${mirror}. /discord mirror on|off, /discord unlink`;
+}
+
+const UNAVAILABLE_OUTCOME: DiscordCommandOutcome = { body: DISCORD_UNAVAILABLE, type: "info" };
+
+async function connect(api: DiscordCommandApi, openUrl: (url: string) => Promise<void>): Promise<DiscordCommandOutcome> {
+  const link = await api.getLink();
+  if (!link.available) return UNAVAILABLE_OUTCOME;
+  if (link.linked) return { body: linkedStatus(link), type: "info" };
+  await openUrl(DISCORD_LINK_URL);
+  return { body: "Opened gloom.sh in your browser to connect Discord", type: "info" };
+}
+
+async function unlink(api: DiscordCommandApi): Promise<DiscordCommandOutcome> {
+  // A 404 from the unlink route alone could mean "no Discord sync" or "nothing linked", so ask first.
+  const link = await api.getLink();
+  if (!link.available) return UNAVAILABLE_OUTCOME;
+  if (!link.linked) return { body: "Discord is not linked", type: "info" };
+  await api.unlink();
+  return { body: "Unlinked from Discord", type: "success" };
+}
+
+/**
+ * Runs one /discord subcommand and says what to tell the user. A server that
+ * has no Discord sync answers 404 or 501, which reads as "not available yet"
+ * and nothing else.
+ */
+export async function runDiscordCommand(
+  command: DiscordComposerCommand,
+  deps: { api?: DiscordCommandApi; openUrl: (url: string) => Promise<void> },
+): Promise<DiscordCommandOutcome> {
+  const api = deps.api ?? discordCommandApi;
+  try {
+    switch (command.action) {
+      case "connect":
+        return await connect(api, deps.openUrl);
+      case "unlink":
+        return await unlink(api);
+      case "mirror":
+        await api.setMirror(command.enabled);
+        return {
+          body: command.enabled ? "Your public messages are mirrored to Discord" : "Your public messages are no longer mirrored to Discord",
+          type: "success",
+        };
+      case "usage":
+        return { body: DISCORD_USAGE, type: "info" };
+    }
+  } catch (error) {
+    if (isUnavailable(error)) return UNAVAILABLE_OUTCOME;
+    return { body: error instanceof Error && error.message ? error.message : "Discord request failed.", type: "error" };
+  }
+}

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

@@ -8,17 +8,23 @@ export function isWithinChatMessageEditWindow(message: ChatMessage, nowMs = Date
   return Number.isFinite(createdMs) && nowMs - createdMs <= CHAT_MESSAGE_EDIT_WINDOW_MS;
 }
 
+/** What the server answers (409) to an edit of a message written on Discord. */
+export const DISCORD_MESSAGE_EDIT_NOTICE = "This message was sent on Discord. Edit it there.";
+
+/** A message written on Discord is edited there; the server refuses an edit of it. */
+export function isEditableOnGloom(message: ChatMessage): boolean {
+  return message.origin !== "discord";
+}
+
 export function findLatestEditableChatMessage(
   messages: ChatMessage[],
   userId: string | null | undefined,
   nowMs = Date.now(),
 ): ChatMessage | null {
   if (!userId) return null;
-  return [...messages]
+  // Only your latest message can be edited, so a Discord one in that place leaves nothing to edit.
+  const latest = [...messages]
     .reverse()
-    .find((message) => (
-      message.user.id === userId
-      && !message.clientStatus
-      && isWithinChatMessageEditWindow(message, nowMs)
-    )) ?? null;
+    .find((message) => message.user.id === userId && !message.clientStatus);
+  return latest && isEditableOnGloom(latest) && isWithinChatMessageEditWindow(latest, nowMs) ? latest : null;
 }

package/src/plugins/builtin/chat/ghost-user.ts

@@ -0,0 +1,14 @@
+import type { ChatUserSummary } from "../../../api-client";
+
+/**
+ * A person on the Gloom Discord with no linked Gloom account. Their messages
+ * show in the channel, but there is no profile to open and no one to message.
+ */
+export function isDiscordGhost(user: Pick<ChatUserSummary, "accountType"> | null | undefined): boolean {
+  return user?.accountType === "discord";
+}
+
+/** The name a message is signed with: the username, or for a ghost that has none the Discord name it carries. */
+export function chatAuthorName(user: Pick<ChatUserSummary, "username" | "displayName" | "accountType">): string {
+  return user.username ?? ((isDiscordGhost(user) && user.displayName?.trim()) || "anon");
+}

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

@@ -10,13 +10,33 @@ import {
   openDmTargetFromCommand,
   parseDmUsernames,
 } from "./channels";
+import { CHAT_REUSE_PANE_VALUE, createChatSearchProvider } from "./command-bar";
 import { chatController } from "./controller";
+import { buildChatConversations, selectChatConversations } from "./conversations";
+import { pickChatPaneToReuse } from "./pane-state";
 import { ChatPane } from "./pane";
 import { chatSidebarStore } from "./sidebar-store";
 import { ChatStatusWidget } from "./status-widget";
 import { UnreadInboxPane } from "./unread-inbox-pane";
 import { UNREAD_INBOX_PANE_ID, UNREAD_INBOX_TEMPLATE_ID } from "./unread-inbox";
 
+/**
+ * `CHAT general` or `CHAT #help` by id; failing that, `CHAT gen` or `CHAT alice`
+ * opens the conversation the command bar lists first for that text.
+ */
+async function resolveTypedChannelId(rawArg: string): Promise<string> {
+  try {
+    return await chatController.resolveRequiredChannelId(normalizeShortcutChannelId(rawArg));
+  } catch (error) {
+    const list = chatController.listConversations();
+    const [best] = list
+      ? selectChatConversations(buildChatConversations(list.states, list.userId), { kind: "search", text: rawArg })
+      : [];
+    if (best) return best.channelId;
+    throw error;
+  }
+}
+
 export const chatModule: PluginModule = {
   panes: [{
     id: "chat",
@@ -47,21 +67,38 @@ export const chatModule: PluginModule = {
     keywords: ["new", "chat", "pane", "message"],
     shortcut: { prefix: "CHAT", argPlaceholder: "channel", argKind: "text" },
     createInstance: async (context, options) => {
+      const reuse = options?.values?.[CHAT_REUSE_PANE_VALUE] === "1";
+      const rawArg = options?.arg?.trim() ?? "";
+      // The command bar's New DM keeps the open pane on its conversation.
+      if (reuse && !rawArg) {
+        const open = pickChatPaneToReuse(context.layout, context.focusedPaneId, null);
+        if (open) return { placement: "floating", instanceId: open.instanceId };
+      }
       // `CHAT MD` or `CHAT "Macro Desk"` opens that team's #general. A raw
       // channel id (team ids are mixed case) is kept as typed.
-      const rawArg = options?.arg?.trim() ?? "";
       const team = rawArg ? teamStore.findTeam(rawArg) : null;
       const channelId = team
         ? teamChannelId(team.id)
         : rawArg && chatController.getChannels().some((entry) => entry.id === rawArg)
         ? rawArg
         : rawArg
-        ? await chatController.resolveRequiredChannelId(normalizeShortcutChannelId(rawArg))
+        ? await resolveTypedChannelId(rawArg)
         : await chatController.resolvePreferredChannelId(
           getPreferredChatOpenChannelId(context.config, chatController.getSnapshot()),
         );
       const channel = chatController.getChannels().find((entry) => entry.id === channelId);
       const targetMessageId = options?.values?.messageId?.trim() || null;
+      // A conversation picked in the command bar goes to the Chat pane that is
+      // open, which switches to it, rather than to a pane of its own.
+      const open = reuse ? pickChatPaneToReuse(context.layout, context.focusedPaneId, channelId) : null;
+      if (open) {
+        return {
+          placement: "floating",
+          instanceId: open.instanceId,
+          title: formatChatPaneTitle(channel, channelId),
+          settings: { channelId },
+        };
+      }
       return {
         placement: "floating",
         // One pane per channel: re-opening the same channel focuses the pane
@@ -93,6 +130,7 @@ export const chatModule: PluginModule = {
     "status:widget": () => <ChatStatusWidget />,
   },
   setup(ctx) {
+    ctx.registerCommandBarSearchProvider(createChatSearchProvider(ctx));
     chatController.attachPersistence(ctx.persistence, ctx.resume);
     chatSidebarStore.attach(ctx.persistence);
     chatController.setNotifier(ctx.notify, (channelId, messageId) => {

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

@@ -23,6 +23,8 @@ export function isGroupedWithPrevious(messages: ChatMessage[], index: number) {
   const prev = messages[index - 1]!;
   const curr = messages[index]!;
   if (prev.user.id !== curr.user.id) return false;
+  // The Discord tag sits on a header, so a linked person's Discord and app messages do not share one.
+  if ((prev.origin === "discord") !== (curr.origin === "discord")) return false;
   return new Date(curr.createdAt).getTime() - new Date(prev.createdAt).getTime() < MESSAGE_GROUP_THRESHOLD_MS;
 }
 

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

@@ -7,6 +7,7 @@ import { useAppLanguage } from "../../../../i18n/react";
 import { normalizeInlinePreview } from "../layout";
 import { DesktopChatMessageImages } from "../attachments/desktop";
 import { chatReplyQuoteText } from "../attachments/model";
+import { chatAuthorName } from "../ghost-user";
 import { ChatMessageActions, ChatMessageHeader } from "./header";
 import { ResponsiveTickerBadgeText } from "./inline-tokens";
 import { useSlowPendingSend } from "./pending-send";
@@ -153,7 +154,7 @@ export const DesktopChatMessage = memo(function DesktopChatMessage({
           <DesktopChatMessageImages
             attachments={attachments}
             caption={msg.content}
-            author={msg.user.username ?? "anon"}
+            author={chatAuthorName(msg.user)}
             review={msg.attachmentReview}
             dimmed={state.isSending || msg.clientStatus === "failed"}
             onLoadError={onImageLoadError}

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

@@ -1,6 +1,8 @@
 import { useRef } from "react";
 import { Box, Text, useUiCapabilities, type BoxRenderable } from "../../../../ui";
 import { t } from "../../../../i18n";
+import { displayWidth } from "../../../../utils/format";
+import { chatAuthorName, isDiscordGhost } from "../ghost-user";
 import { Button } from "../../../../components/ui";
 import { MESSAGE_ACTION_WIDTH } from "../layout";
 import type { ChatMessageRenderState } from "./render-state";
@@ -82,7 +84,9 @@ export function ChatMessageHeader({
   /** The terminal sizes the author cell to its label. */
   fitAuthorWidth?: boolean;
 }) {
-  const authorLabel = msg.user.username ?? "anon";
+  const authorLabel = chatAuthorName(msg.user);
+  // A Discord ghost has no Gloom profile to open and no one to message.
+  const hasProfile = !isDiscordGhost(msg.user);
   const { nativeContextMenu } = useUiCapabilities();
   // The card opens beside the name the pointer is on.
   const nameRef = useRef<BoxRenderable | null>(null);
@@ -90,26 +94,31 @@ export function ChatMessageHeader({
     <Box {...rowProps} flexDirection="row" height={1} paddingLeft={1}>
       <Box
         ref={nameRef}
-        width={fitAuthorWidth ? authorLabel.length : undefined}
+        width={fitAuthorWidth ? displayWidth(authorLabel) : undefined}
         height={1}
-        onMouseOver={() => onUserHover(msg.user, nameRef.current)}
-        onMouseMove={() => onUserHover(msg.user, nameRef.current)}
-        onMouseOut={onUserHoverEnd}
-        data-gloom-context-menu-surface="true"
-        onMouseDown={(event: { button?: number; preventDefault?: () => void; stopPropagation?: () => void }) => {
-          event.preventDefault?.();
-          event.stopPropagation?.();
-          // A native menu opens on the right-click's contextmenu event instead.
-          if (event.button === 2 && nativeContextMenu === true) return;
-          onUserActivate?.(msg.user, nameRef.current);
-        }}
-        onContextMenu={(event: { preventDefault?: () => void; stopPropagation?: () => void }) => onUserContextMenu?.(msg.user, event, nameRef.current)}
-        style={{ cursor: "pointer" }}
+        {...(hasProfile
+          ? {
+            onMouseOver: () => onUserHover(msg.user, nameRef.current),
+            onMouseMove: () => onUserHover(msg.user, nameRef.current),
+            onMouseOut: onUserHoverEnd,
+            "data-gloom-context-menu-surface": "true",
+            onMouseDown: (event: { button?: number; preventDefault?: () => void; stopPropagation?: () => void }) => {
+              event.preventDefault?.();
+              event.stopPropagation?.();
+              // A native menu opens on the right-click's contextmenu event instead.
+              if (event.button === 2 && nativeContextMenu === true) return;
+              onUserActivate?.(msg.user, nameRef.current);
+            },
+            onContextMenu: (event: { preventDefault?: () => void; stopPropagation?: () => void }) => onUserContextMenu?.(msg.user, event, nameRef.current),
+            style: { cursor: "pointer" },
+          }
+          : {})}
       >
         <Text fg={state.authorColor} attributes={state.authorAttributes}>
           {authorLabel}
         </Text>
       </Box>
+      {msg.origin === "discord" && <Text fg={state.originTagColor}> Discord</Text>}
       <Text fg={state.headerStatusColor}> {state.headerStatus}</Text>
       {(state.showReplyAction || (state.showRetryAction && actionProps.retryMessage)) && <Text fg={state.headerStatusColor}> </Text>}
       <ChatMessageActions state={state} {...actionProps} />

package/src/plugins/builtin/chat/message/profile-popover.tsx

@@ -5,6 +5,7 @@ import { colors } from "../../../../theme/colors";
 import type { ChatUserSummary, PublicPortfolioAnalytics } from "../../../../api-client";
 import { displayWidth, formatNumber, truncateToDisplayWidth } from "../../../../utils/format";
 import { truncateWithEllipsis } from "../../../../utils/text-wrap";
+import { isDiscordGhost } from "../ghost-user";
 import type { ChatUserAnchor } from "./types";
 
 /**
@@ -24,7 +25,7 @@ function hasPortfolioAnalytics(analytics: PublicPortfolioAnalytics | null | unde
 }
 
 export function hasPublicChatProfileInfo(user: ChatUserSummary): boolean {
-  if (user.profilePublic === false) return false;
+  if (user.profilePublic === false || isDiscordGhost(user)) return false;
   return Boolean(user.bio?.trim() || user.title?.trim() || user.company?.trim() || hasPortfolioAnalytics(user.portfolioAnalytics));
 }