@chat-adapter/slack 4.20.0 → 4.20.2

package/dist/index.d.ts

@@ -107,6 +107,18 @@ interface SlackThreadId {
 }
 /** Slack event payload (raw message format) */
 interface SlackEvent {
+    /** Rich text blocks containing structured elements (links, mentions, etc.) */
+    blocks?: Array<{
+        type: string;
+        elements?: Array<{
+            type: string;
+            elements?: Array<{
+                type: string;
+                url?: string;
+                text?: string;
+            }>;
+        }>;
+    }>;
     bot_id?: string;
     channel?: string;
     /** Channel type: "channel", "group", "mpim", or "im" (DM) */
@@ -162,6 +174,8 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     private _botId;
     private readonly formatConverter;
     private static USER_CACHE_TTL_MS;
+    private static CHANNEL_CACHE_TTL_MS;
+    private static REVERSE_INDEX_TTL_MS;
     private readonly clientId;
     private readonly clientSecret;
     private readonly encryptionKey;
@@ -222,6 +236,11 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Returns display name and real name, or falls back to user ID.
      */
     private lookupUser;
+    /**
+     * Look up channel name from Slack API with caching via state adapter.
+     * Returns channel name, or falls back to channel ID.
+     */
+    private lookupChannel;
     handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
     /** Extract and dispatch events from a validated payload */
     private processEventPayload;
@@ -273,6 +292,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Fires when a user (including the bot) joins a channel.
      */
     private handleMemberJoinedChannel;
+    private handleUserChange;
     /**
      * Publish a Home tab view for a user.
      * Slack API: views.publish
@@ -307,20 +327,41 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      *   detection doesn't apply.
      */
     private resolveInlineMentions;
+    /**
+     * Extract link URLs from a Slack event.
+     * Uses the `blocks` field (rich_text blocks with link elements) when available,
+     * falling back to parsing `<url>` patterns from the text field.
+     */
+    private extractLinks;
+    /**
+     * Create a LinkPreview for a URL. If the URL points to a Slack message,
+     * includes a `fetchMessage` callback that fetches and parses the linked message.
+     */
+    private createLinkPreview;
     private parseSlackMessage;
     /**
      * Create an Attachment object from a Slack file.
      * Includes a fetchData method that uses the bot token for auth.
      */
     private createAttachment;
+    /**
+     * Resolve @name mentions in text to Slack <@USER_ID> format using the
+     * reverse user cache. When multiple users share a display name, prefers
+     * the one who is a participant in the given thread.
+     */
+    private resolveOutgoingMentions;
+    /**
+     * Pre-process an outgoing message to resolve @name mentions before rendering.
+     */
+    private resolveMessageMentions;
     /**
      * Try to render a message using native Slack table blocks.
      * Returns blocks + fallback text if the message contains tables, null otherwise.
      */
     private renderWithTableBlocks;
-    postMessage(threadId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
-    postEphemeral(threadId: string, userId: string, message: AdapterPostableMessage): Promise<EphemeralMessage>;
-    scheduleMessage(threadId: string, message: AdapterPostableMessage, options: {
+    postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
+    postEphemeral(threadId: string, userId: string, _message: AdapterPostableMessage): Promise<EphemeralMessage>;
+    scheduleMessage(threadId: string, _message: AdapterPostableMessage, options: {
         postAt: Date;
     }): Promise<ScheduledMessage>;
     openModal(triggerId: string, modal: ModalElement, contextId?: string): Promise<{
@@ -334,7 +375,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Returns the file IDs of uploaded files.
      */
     private uploadFiles;
-    editMessage(threadId: string, messageId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
+    editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
     deleteMessage(threadId: string, messageId: string): Promise<void>;
     addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
     removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;

package/dist/index.js

@@ -708,6 +708,19 @@ function radioSelectToBlock(radioSelect) {
 
 // src/index.ts
 var SLACK_USER_ID_PATTERN = /^[A-Z0-9_]+$/;
+var SLACK_USER_ID_EXACT_PATTERN = /^U[A-Z0-9]+$/;
+function findNextMention(text) {
+  const atIdx = text.indexOf("<@");
+  const hashIdx = text.indexOf("<#");
+  if (atIdx === -1) {
+    return hashIdx;
+  }
+  if (hashIdx === -1) {
+    return atIdx;
+  }
+  return Math.min(atIdx, hashIdx);
+}
+var SLACK_MESSAGE_URL_PATTERN = /^https?:\/\/[^/]+\.slack\.com\/archives\/([A-Z0-9]+)\/p(\d+)(?:\?.*)?$/;
 var SlackAdapter = class _SlackAdapter {
   name = "slack";
   userName;
@@ -720,8 +733,12 @@ var SlackAdapter = class _SlackAdapter {
   _botId = null;
   // Bot app ID (B_xxx) - different from user ID
   formatConverter = new SlackFormatConverter();
-  static USER_CACHE_TTL_MS = 60 * 60 * 1e3;
-  // 1 hour
+  static USER_CACHE_TTL_MS = 8 * 24 * 60 * 60 * 1e3;
+  // 8 days
+  static CHANNEL_CACHE_TTL_MS = 8 * 24 * 60 * 60 * 1e3;
+  // 8 days
+  static REVERSE_INDEX_TTL_MS = 8 * 24 * 60 * 60 * 1e3;
+  // 8 days
   // Multi-workspace support
   clientId;
   clientSecret;
@@ -992,6 +1009,15 @@ var SlackAdapter = class _SlackAdapter {
           { displayName, realName },
           _SlackAdapter.USER_CACHE_TTL_MS
         );
+        const normalizedName = displayName.toLowerCase();
+        const reverseKey = `slack:user-by-name:${normalizedName}`;
+        const existing = await this.chat.getState().getList(reverseKey);
+        if (!existing.includes(userId)) {
+          await this.chat.getState().appendToList(reverseKey, userId, {
+            maxLength: 50,
+            ttlMs: _SlackAdapter.REVERSE_INDEX_TTL_MS
+          });
+        }
       }
       this.logger.debug("Fetched user info", {
         userId,
@@ -1004,6 +1030,37 @@ var SlackAdapter = class _SlackAdapter {
       return { displayName: userId, realName: userId };
     }
   }
+  /**
+   * Look up channel name from Slack API with caching via state adapter.
+   * Returns channel name, or falls back to channel ID.
+   */
+  async lookupChannel(channelId) {
+    const cacheKey = `slack:channel:${channelId}`;
+    if (this.chat) {
+      const cached = await this.chat.getState().get(cacheKey);
+      if (cached) {
+        return cached.name;
+      }
+    }
+    try {
+      const result = await this.client.conversations.info(
+        this.withToken({ channel: channelId })
+      );
+      const name = result.channel?.name || channelId;
+      if (this.chat) {
+        await this.chat.getState().set(
+          cacheKey,
+          { name },
+          _SlackAdapter.CHANNEL_CACHE_TTL_MS
+        );
+      }
+      this.logger.debug("Fetched channel info", { channelId, name });
+      return name;
+    } catch (error) {
+      this.logger.warn("Could not fetch channel info", { channelId, error });
+      return channelId;
+    }
+  }
   async handleWebhook(request, options) {
     const body = await request.text();
     this.logger.debug("Slack webhook raw body", { body });
@@ -1099,6 +1156,8 @@ var SlackAdapter = class _SlackAdapter {
           event,
           options
         );
+      } else if (event.type === "user_change") {
+        this.handleUserChange(event);
       }
     }
   }
@@ -1605,6 +1664,19 @@ var SlackAdapter = class _SlackAdapter {
       options
     );
   }
+  async handleUserChange(event) {
+    if (!this.chat) {
+      return;
+    }
+    try {
+      await this.chat.getState().delete(`slack:user:${event.user.id}`);
+    } catch (error) {
+      this.logger.warn("Failed to invalidate user cache", {
+        userId: event.user.id,
+        error
+      });
+    }
+  }
   /**
    * Publish a Home tab view for a user.
    * Slack API: views.publish
@@ -1668,41 +1740,56 @@ var SlackAdapter = class _SlackAdapter {
    */
   async resolveInlineMentions(text, skipSelfMention) {
     const userIds = /* @__PURE__ */ new Set();
+    const channelIds = /* @__PURE__ */ new Set();
     for (const segment of text.split("<")) {
       const end = segment.indexOf(">");
       if (end === -1) {
         continue;
       }
       const inner = segment.slice(0, end);
-      if (!inner.startsWith("@")) {
-        continue;
-      }
-      const rest = inner.slice(1);
-      const pipeIdx = rest.indexOf("|");
-      const uid = pipeIdx >= 0 ? rest.slice(0, pipeIdx) : rest;
-      if (SLACK_USER_ID_PATTERN.test(uid)) {
-        userIds.add(uid);
+      if (inner.startsWith("@")) {
+        const rest = inner.slice(1);
+        const pipeIdx = rest.indexOf("|");
+        const uid = pipeIdx >= 0 ? rest.slice(0, pipeIdx) : rest;
+        if (SLACK_USER_ID_PATTERN.test(uid)) {
+          userIds.add(uid);
+        }
+      } else if (inner.startsWith("#")) {
+        const rest = inner.slice(1);
+        const pipeIdx = rest.indexOf("|");
+        if (pipeIdx === -1 && SLACK_USER_ID_PATTERN.test(rest)) {
+          channelIds.add(rest);
+        }
       }
     }
-    if (userIds.size === 0) {
+    if (userIds.size === 0 && channelIds.size === 0) {
       return text;
     }
     if (skipSelfMention && this._botUserId) {
       userIds.delete(this._botUserId);
     }
-    if (userIds.size === 0) {
+    if (userIds.size === 0 && channelIds.size === 0) {
       return text;
     }
-    const lookups = await Promise.all(
-      [...userIds].map(async (uid) => {
-        const info = await this.lookupUser(uid);
-        return [uid, info.displayName];
-      })
-    );
-    const nameMap = new Map(lookups);
+    const [userLookups, channelLookups] = await Promise.all([
+      Promise.all(
+        [...userIds].map(async (uid) => {
+          const info = await this.lookupUser(uid);
+          return [uid, info.displayName];
+        })
+      ),
+      Promise.all(
+        [...channelIds].map(async (cid) => {
+          const name = await this.lookupChannel(cid);
+          return [cid, name];
+        })
+      )
+    ]);
+    const userNameMap = new Map(userLookups);
+    const channelNameMap = new Map(channelLookups);
     let result = "";
     let remaining = text;
-    let startIdx = remaining.indexOf("<@");
+    let startIdx = findNextMention(remaining);
     while (startIdx !== -1) {
       result += remaining.slice(0, startIdx);
       remaining = remaining.slice(startIdx);
@@ -1710,20 +1797,89 @@ var SlackAdapter = class _SlackAdapter {
       if (endIdx === -1) {
         break;
       }
+      const prefix = remaining[1];
       const inner = remaining.slice(2, endIdx);
       const pipeIdx = inner.indexOf("|");
-      const uid = pipeIdx >= 0 ? inner.slice(0, pipeIdx) : inner;
-      if (SLACK_USER_ID_PATTERN.test(uid)) {
-        const name = nameMap.get(uid);
-        result += name ? `<@${uid}|${name}>` : `<@${uid}>`;
+      const id = pipeIdx >= 0 ? inner.slice(0, pipeIdx) : inner;
+      if (prefix === "@" && SLACK_USER_ID_PATTERN.test(id)) {
+        const name = userNameMap.get(id);
+        result += name ? `<@${id}|${name}>` : `<@${id}>`;
+      } else if (prefix === "#" && pipeIdx === -1 && channelNameMap.has(id)) {
+        const name = channelNameMap.get(id);
+        result += `<#${id}|${name}>`;
       } else {
         result += remaining.slice(0, endIdx + 1);
       }
       remaining = remaining.slice(endIdx + 1);
-      startIdx = remaining.indexOf("<@");
+      startIdx = findNextMention(remaining);
     }
     return result + remaining;
   }
+  /**
+   * Extract link URLs from a Slack event.
+   * Uses the `blocks` field (rich_text blocks with link elements) when available,
+   * falling back to parsing `<url>` patterns from the text field.
+   */
+  extractLinks(event) {
+    const urls = /* @__PURE__ */ new Set();
+    if (event.blocks) {
+      for (const block of event.blocks) {
+        if (block.type === "rich_text" && block.elements) {
+          for (const section of block.elements) {
+            if (section.elements) {
+              for (const element of section.elements) {
+                if (element.type === "link" && element.url) {
+                  urls.add(element.url);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (urls.size === 0 && event.text) {
+      const urlPattern = /<(https?:\/\/[^>]+)>/g;
+      for (const match of event.text.matchAll(urlPattern)) {
+        const raw = match[1];
+        const pipeIdx = raw.indexOf("|");
+        urls.add(pipeIdx >= 0 ? raw.slice(0, pipeIdx) : raw);
+      }
+    }
+    return [...urls].map((url) => this.createLinkPreview(url));
+  }
+  /**
+   * Create a LinkPreview for a URL. If the URL points to a Slack message,
+   * includes a `fetchMessage` callback that fetches and parses the linked message.
+   */
+  createLinkPreview(url) {
+    const match = SLACK_MESSAGE_URL_PATTERN.exec(url);
+    if (!match) {
+      return { url };
+    }
+    const channel = match[1];
+    const rawTs = match[2];
+    const ts = `${rawTs.slice(0, rawTs.length - 6)}.${rawTs.slice(rawTs.length - 6)}`;
+    const threadId = this.encodeThreadId({ channel, threadTs: ts });
+    return {
+      url,
+      fetchMessage: async () => {
+        const result = await this.client.conversations.history(
+          this.withToken({
+            channel,
+            latest: ts,
+            inclusive: true,
+            limit: 1
+          })
+        );
+        const messages = result.messages || [];
+        const target = messages.find((msg) => msg.ts === ts);
+        if (!target) {
+          throw new Error(`Message not found: ${url}`);
+        }
+        return this.parseSlackMessage(target, threadId);
+      }
+    };
+  }
   async parseSlackMessage(event, threadId, options) {
     const isMe = this.isMessageFromSelf(event);
     const skipSelfMention = options?.skipSelfMention ?? true;
@@ -1735,6 +1891,24 @@ var SlackAdapter = class _SlackAdapter {
       userName = userInfo.displayName;
       fullName = userInfo.realName;
     }
+    if (event.user && this.chat) {
+      try {
+        const participantKey = `slack:thread-participants:${threadId}`;
+        const participants = await this.chat.getState().getList(participantKey);
+        if (!participants.includes(event.user)) {
+          await this.chat.getState().appendToList(participantKey, event.user, {
+            maxLength: 100,
+            ttlMs: _SlackAdapter.REVERSE_INDEX_TTL_MS
+          });
+        }
+      } catch (error) {
+        this.logger.warn("Failed to track thread participant", {
+          threadId,
+          userId: event.user,
+          error
+        });
+      }
+    }
     const text = await this.resolveInlineMentions(rawText, skipSelfMention);
     return new Message({
       id: event.ts || "",
@@ -1756,7 +1930,8 @@ var SlackAdapter = class _SlackAdapter {
       },
       attachments: (event.files || []).map(
         (file) => this.createAttachment(file)
-      )
+      ),
+      links: this.extractLinks(event)
     });
   }
   /**
@@ -1794,11 +1969,119 @@ var SlackAdapter = class _SlackAdapter {
             `Failed to fetch file: ${response.status} ${response.statusText}`
           );
         }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("text/html")) {
+          throw new NetworkError(
+            "slack",
+            `Failed to download file from Slack: received HTML login page instead of file data. Ensure your Slack app has the "files:read" OAuth scope. URL: ${url}`
+          );
+        }
         const arrayBuffer = await response.arrayBuffer();
         return Buffer.from(arrayBuffer);
       } : void 0
     };
   }
+  /**
+   * Resolve @name mentions in text to Slack <@USER_ID> format using the
+   * reverse user cache. When multiple users share a display name, prefers
+   * the one who is a participant in the given thread.
+   */
+  async resolveOutgoingMentions(text, threadId) {
+    if (!this.chat) {
+      return text;
+    }
+    const state = this.chat.getState();
+    const mentionPattern = /@(\w+)/g;
+    const mentions = /* @__PURE__ */ new Map();
+    for (const match of text.matchAll(mentionPattern)) {
+      const name = match[1];
+      if (SLACK_USER_ID_EXACT_PATTERN.test(name)) {
+        continue;
+      }
+      const idx = match.index;
+      if (idx > 0 && text[idx - 1] === "<") {
+        continue;
+      }
+      if (!mentions.has(name.toLowerCase())) {
+        mentions.set(name.toLowerCase(), []);
+      }
+    }
+    if (mentions.size === 0) {
+      return text;
+    }
+    for (const name of mentions.keys()) {
+      const userIds = await state.getList(`slack:user-by-name:${name}`);
+      const unique = [...new Set(userIds)];
+      mentions.set(name, unique);
+    }
+    let participants = null;
+    const needsParticipants = [...mentions.values()].some(
+      (ids) => ids.length > 1
+    );
+    if (needsParticipants) {
+      const participantList = await state.getList(
+        `slack:thread-participants:${threadId}`
+      );
+      participants = new Set(participantList);
+    }
+    return text.replace(
+      mentionPattern,
+      (match, name, offset) => {
+        if (offset > 0 && text[offset - 1] === "<") {
+          return match;
+        }
+        if (SLACK_USER_ID_EXACT_PATTERN.test(name)) {
+          return match;
+        }
+        const userIds = mentions.get(name.toLowerCase());
+        if (!userIds || userIds.length === 0) {
+          return match;
+        }
+        if (userIds.length === 1) {
+          return `<@${userIds[0]}>`;
+        }
+        if (participants) {
+          const inThread = userIds.filter((id) => participants.has(id));
+          if (inThread.length === 1) {
+            return `<@${inThread[0]}>`;
+          }
+        }
+        return match;
+      }
+    );
+  }
+  /**
+   * Pre-process an outgoing message to resolve @name mentions before rendering.
+   */
+  async resolveMessageMentions(message, threadId) {
+    if (!this.chat) {
+      return message;
+    }
+    if (typeof message === "string") {
+      return this.resolveOutgoingMentions(message, threadId);
+    }
+    if (typeof message === "object" && message !== null) {
+      if ("raw" in message && typeof message.raw === "string") {
+        return {
+          ...message,
+          raw: await this.resolveOutgoingMentions(
+            message.raw,
+            threadId
+          )
+        };
+      }
+      if ("markdown" in message && typeof message.markdown === "string") {
+        return {
+          ...message,
+          markdown: await this.resolveOutgoingMentions(
+            message.markdown,
+            threadId
+          )
+        };
+      }
+    }
+    return message;
+  }
   /**
    * Try to render a message using native Slack table blocks.
    * Returns blocks + fallback text if the message contains tables, null otherwise.
@@ -1825,7 +2108,8 @@ var SlackAdapter = class _SlackAdapter {
     );
     return { text: fallbackText, blocks };
   }
-  async postMessage(threadId, message) {
+  async postMessage(threadId, _message) {
+    const message = await this.resolveMessageMentions(_message, threadId);
     const { channel, threadTs } = this.decodeThreadId(threadId);
     try {
       const files = extractFiles(message);
@@ -1929,7 +2213,8 @@ var SlackAdapter = class _SlackAdapter {
       this.handleSlackError(error);
     }
   }
-  async postEphemeral(threadId, userId, message) {
+  async postEphemeral(threadId, userId, _message) {
+    const message = await this.resolveMessageMentions(_message, threadId);
     const { channel, threadTs } = this.decodeThreadId(threadId);
     try {
       const card = extractCard(message);
@@ -2022,7 +2307,8 @@ var SlackAdapter = class _SlackAdapter {
       this.handleSlackError(error);
     }
   }
-  async scheduleMessage(threadId, message, options) {
+  async scheduleMessage(threadId, _message, options) {
+    const message = await this.resolveMessageMentions(_message, threadId);
     const { channel, threadTs } = this.decodeThreadId(threadId);
     const postAtUnix = Math.floor(options.postAt.getTime() / 1e3);
     if (postAtUnix <= Math.floor(Date.now() / 1e3)) {
@@ -2208,7 +2494,8 @@ var SlackAdapter = class _SlackAdapter {
     }
     return fileIds;
   }
-  async editMessage(threadId, messageId, message) {
+  async editMessage(threadId, messageId, _message) {
+    const message = await this.resolveMessageMentions(_message, threadId);
     const ephemeral = this.decodeEphemeralMessageId(messageId);
     if (ephemeral) {
       const { threadTs } = this.decodeThreadId(threadId);
@@ -2769,7 +3056,8 @@ var SlackAdapter = class _SlackAdapter {
       },
       attachments: (event.files || []).map(
         (file) => this.createAttachment(file)
-      )
+      ),
+      links: this.extractLinks(event)
     });
   }
   // =========================================================================