@chat-adapter/slack 4.10.1 → 4.12.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { CardElement, BaseFormatConverter, AdapterPostableMessage, Root, Logger, Adapter, ChatInstance, WebhookOptions, RawMessage, EphemeralMessage, ModalElement, EmojiValue, StreamOptions, FetchOptions, FetchResult, ThreadInfo, Message, FormattedContent } from 'chat';
+import { CardElement, BaseFormatConverter, AdapterPostableMessage, Root, Logger, Adapter, ChatInstance, WebhookOptions, RawMessage, EphemeralMessage, ModalElement, EmojiValue, StreamOptions, FetchOptions, FetchResult, ThreadInfo, Message, ListThreadsOptions, ListThreadsResult, ChannelInfo, FormattedContent } from 'chat';
 
 /**
  * Slack Block Kit converter for cross-platform cards.
@@ -121,6 +121,10 @@ interface SlackEvent {
     }>;
     team?: string;
     team_id?: string;
+    /** Number of replies in the thread (present on thread parent messages) */
+    reply_count?: number;
+    /** Timestamp of the latest reply (present on thread parent messages) */
+    latest_reply?: string;
 }
 /** Slack reaction event payload */
 interface SlackReactionEvent {
@@ -214,6 +218,11 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * These are sent as form-urlencoded with a `payload` JSON field.
      */
     private handleInteractivePayload;
+    /**
+     * Handle Slack slash command payloads.
+     * Slash commands are sent as form-urlencoded with command, text, user_id, channel_id, etc.
+     */
+    private handleSlashCommand;
     /**
      * Handle block_actions payload (button clicks in Block Kit).
      */
@@ -232,6 +241,17 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Handle reaction events from Slack (reaction_added, reaction_removed).
      */
     private handleReactionEvent;
+    /**
+     * Resolve inline user mentions in Slack mrkdwn text.
+     * Converts <@U123> to <@U123|displayName> so that toAst/extractPlainText
+     * renders them as @displayName instead of @U123.
+     *
+     * @param skipSelfMention - When true, skips the bot's own user ID so that
+     *   mention detection (which looks for @botUserId in the text) continues to
+     *   work. Set to false when parsing historical/channel messages where mention
+     *   detection doesn't apply.
+     */
+    private resolveInlineMentions;
     private parseSlackMessage;
     /**
      * Create an Attachment object from a Slack file.
@@ -304,6 +324,30 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Used for parseMessage interface - falls back to user ID for username.
      */
     private parseSlackMessageSync;
+    /**
+     * Derive channel ID from a Slack thread ID.
+     * Slack thread IDs are "slack:CHANNEL:THREAD_TS", channel ID is "slack:CHANNEL".
+     */
+    channelIdFromThreadId(threadId: string): string;
+    /**
+     * Fetch channel-level messages (conversations.history, not thread replies).
+     */
+    fetchChannelMessages(channelId: string, options?: FetchOptions): Promise<FetchResult<unknown>>;
+    private fetchChannelMessagesForward;
+    private fetchChannelMessagesBackward;
+    /**
+     * List threads in a Slack channel.
+     * Fetches channel history and filters for messages with replies.
+     */
+    listThreads(channelId: string, options?: ListThreadsOptions): Promise<ListThreadsResult<unknown>>;
+    /**
+     * Fetch Slack channel info/metadata.
+     */
+    fetchChannelInfo(channelId: string): Promise<ChannelInfo>;
+    /**
+     * Post a top-level message to a channel (not in a thread).
+     */
+    postChannelMessage(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
     renderFormatted(content: FormattedContent): string;
     /**
      * Check if a Slack event is from this bot.

package/dist/index.js

@@ -110,11 +110,17 @@ function convertDividerToBlock(_element) {
   return { type: "divider" };
 }
 function convertActionsToBlock(element) {
-  const elements = element.children.map((button) => {
-    if (button.type === "link-button") {
-      return convertLinkButtonToElement(button);
+  const elements = element.children.map((child) => {
+    if (child.type === "link-button") {
+      return convertLinkButtonToElement(child);
     }
-    return convertButtonToElement(button);
+    if (child.type === "select") {
+      return convertSelectToElement(child);
+    }
+    if (child.type === "radio_select") {
+      return convertRadioSelectToElement(child);
+    }
+    return convertButtonToElement(child);
   });
   return {
     type: "actions",
@@ -157,6 +163,69 @@ function convertLinkButtonToElement(button) {
   }
   return element;
 }
+function convertSelectToElement(select) {
+  const options = select.options.map((opt) => {
+    const option = {
+      text: { type: "plain_text", text: convertEmoji(opt.label) },
+      value: opt.value
+    };
+    if (opt.description) {
+      option.description = {
+        type: "plain_text",
+        text: convertEmoji(opt.description)
+      };
+    }
+    return option;
+  });
+  const element = {
+    type: "static_select",
+    action_id: select.id,
+    options
+  };
+  if (select.placeholder) {
+    element.placeholder = {
+      type: "plain_text",
+      text: convertEmoji(select.placeholder)
+    };
+  }
+  if (select.initialOption) {
+    const initialOpt = options.find((o) => o.value === select.initialOption);
+    if (initialOpt) {
+      element.initial_option = initialOpt;
+    }
+  }
+  return element;
+}
+function convertRadioSelectToElement(radioSelect) {
+  const limitedOptions = radioSelect.options.slice(0, 10);
+  const options = limitedOptions.map((opt) => {
+    const option = {
+      text: { type: "mrkdwn", text: convertEmoji(opt.label) },
+      value: opt.value
+    };
+    if (opt.description) {
+      option.description = {
+        type: "mrkdwn",
+        text: convertEmoji(opt.description)
+      };
+    }
+    return option;
+  });
+  const element = {
+    type: "radio_buttons",
+    action_id: radioSelect.id,
+    options
+  };
+  if (radioSelect.initialOption) {
+    const initialOpt = options.find(
+      (o) => o.value === radioSelect.initialOption
+    );
+    if (initialOpt) {
+      element.initial_option = initialOpt;
+    }
+  }
+  return element;
+}
 function convertSectionToBlocks(element) {
   const blocks = [];
   for (const child of element.children) {
@@ -400,6 +469,8 @@ function modalChildToBlock(child) {
       return textInputToBlock(child);
     case "select":
       return selectToBlock(child);
+    case "radio_select":
+      return radioSelectToBlock(child);
     case "text":
       return convertTextToBlock(child);
     case "fields":
@@ -430,10 +501,16 @@ function textInputToBlock(input) {
   };
 }
 function selectToBlock(select) {
-  const options = select.options.map((opt) => ({
-    text: { type: "plain_text", text: opt.label },
-    value: opt.value
-  }));
+  const options = select.options.map((opt) => {
+    const option = {
+      text: { type: "plain_text", text: opt.label },
+      value: opt.value
+    };
+    if (opt.description) {
+      option.description = { type: "plain_text", text: opt.description };
+    }
+    return option;
+  });
   const element = {
     type: "static_select",
     action_id: select.id,
@@ -443,7 +520,9 @@ function selectToBlock(select) {
     element.placeholder = { type: "plain_text", text: select.placeholder };
   }
   if (select.initialOption) {
-    const initialOpt = options.find((o) => o.value === select.initialOption);
+    const initialOpt = options.find(
+      (o) => o.value === select.initialOption
+    );
     if (initialOpt) {
       element.initial_option = initialOpt;
     }
@@ -456,6 +535,39 @@ function selectToBlock(select) {
     element
   };
 }
+function radioSelectToBlock(radioSelect) {
+  const limitedOptions = radioSelect.options.slice(0, 10);
+  const options = limitedOptions.map((opt) => {
+    const option = {
+      text: { type: "mrkdwn", text: opt.label },
+      value: opt.value
+    };
+    if (opt.description) {
+      option.description = { type: "mrkdwn", text: opt.description };
+    }
+    return option;
+  });
+  const element = {
+    type: "radio_buttons",
+    action_id: radioSelect.id,
+    options
+  };
+  if (radioSelect.initialOption) {
+    const initialOpt = options.find(
+      (o) => o.value === radioSelect.initialOption
+    );
+    if (initialOpt) {
+      element.initial_option = initialOpt;
+    }
+  }
+  return {
+    type: "input",
+    block_id: radioSelect.id,
+    optional: radioSelect.optional ?? false,
+    label: { type: "plain_text", text: radioSelect.label },
+    element
+  };
+}
 
 // src/index.ts
 var SlackAdapter = class _SlackAdapter {
@@ -742,6 +854,21 @@ var SlackAdapter = class _SlackAdapter {
     }
     const contentType = request.headers.get("content-type") || "";
     if (contentType.includes("application/x-www-form-urlencoded")) {
+      const params = new URLSearchParams(body);
+      if (params.has("command") && !params.has("payload")) {
+        const teamId = params.get("team_id");
+        if (!this.defaultBotToken && teamId) {
+          const ctx = await this.resolveTokenForTeam(teamId);
+          if (ctx) {
+            return this.requestContext.run(
+              ctx,
+              () => this.handleSlashCommand(params, options)
+            );
+          }
+          this.logger.warn("Could not resolve token for slash command");
+        }
+        return this.handleSlashCommand(params, options);
+      }
       if (!this.defaultBotToken) {
         const teamId = this.extractTeamIdFromInteractive(body);
         if (teamId) {
@@ -829,6 +956,46 @@ var SlackAdapter = class _SlackAdapter {
         return new Response("", { status: 200 });
     }
   }
+  /**
+   * Handle Slack slash command payloads.
+   * Slash commands are sent as form-urlencoded with command, text, user_id, channel_id, etc.
+   */
+  async handleSlashCommand(params, options) {
+    if (!this.chat) {
+      this.logger.warn("Chat instance not initialized, ignoring slash command");
+      return new Response("", { status: 200 });
+    }
+    const command = params.get("command") || "";
+    const text = params.get("text") || "";
+    const userId = params.get("user_id") || "";
+    const channelId = params.get("channel_id") || "";
+    const triggerId = params.get("trigger_id") || void 0;
+    this.logger.debug("Processing Slack slash command", {
+      command,
+      text,
+      userId,
+      channelId,
+      triggerId
+    });
+    const userInfo = await this.lookupUser(userId);
+    const event = {
+      command,
+      text,
+      user: {
+        userId,
+        userName: userInfo.displayName,
+        fullName: userInfo.realName,
+        isBot: false,
+        isMe: false
+      },
+      adapter: this,
+      raw: Object.fromEntries(params),
+      triggerId,
+      channelId: channelId ? `slack:${channelId}` : ""
+    };
+    this.chat.processSlashCommand(event, options);
+    return new Response("", { status: 200 });
+  }
   /**
    * Handle block_actions payload (button clicks in Block Kit).
    */
@@ -855,9 +1022,10 @@ var SlackAdapter = class _SlackAdapter {
     const responseUrl = payload.response_url;
     const messageId = isEphemeral && responseUrl ? this.encodeEphemeralMessageId(messageTs, responseUrl, payload.user.id) : messageTs;
     for (const action of payload.actions) {
+      const actionValue = action.selected_option?.value ?? action.value;
       const actionEvent = {
         actionId: action.action_id,
-        value: action.value,
+        value: actionValue,
         user: {
           userId: payload.user.id,
           userName: payload.user.username || payload.user.name || "unknown",
@@ -1036,17 +1204,20 @@ var SlackAdapter = class _SlackAdapter {
       return;
     }
     const isDM = event.channel_type === "im";
-    const threadTs = isDM ? "" : event.thread_ts || event.ts;
+    const threadTs = isDM ? event.thread_ts || "" : event.thread_ts || event.ts;
     const threadId = this.encodeThreadId({
       channel: event.channel,
       threadTs
     });
-    this.chat.processMessage(
-      this,
-      threadId,
-      () => this.parseSlackMessage(event, threadId),
-      options
-    );
+    const isMention = isDM || event.type === "app_mention";
+    const factory = async () => {
+      const msg = await this.parseSlackMessage(event, threadId);
+      if (isMention) {
+        msg.isMention = true;
+      }
+      return msg;
+    };
+    this.chat.processMessage(this, threadId, factory, options);
   }
   /**
    * Handle reaction events from Slack (reaction_added, reaction_removed).
@@ -1090,9 +1261,45 @@ var SlackAdapter = class _SlackAdapter {
     };
     this.chat.processReaction({ ...reactionEvent, adapter: this }, options);
   }
-  async parseSlackMessage(event, threadId) {
+  /**
+   * Resolve inline user mentions in Slack mrkdwn text.
+   * Converts <@U123> to <@U123|displayName> so that toAst/extractPlainText
+   * renders them as @displayName instead of @U123.
+   *
+   * @param skipSelfMention - When true, skips the bot's own user ID so that
+   *   mention detection (which looks for @botUserId in the text) continues to
+   *   work. Set to false when parsing historical/channel messages where mention
+   *   detection doesn't apply.
+   */
+  async resolveInlineMentions(text, skipSelfMention) {
+    const mentionPattern = /<@([A-Z0-9]+)(?:\|[^>]*)?>/g;
+    const userIds = /* @__PURE__ */ new Set();
+    let match = mentionPattern.exec(text);
+    while (match) {
+      userIds.add(match[1]);
+      match = mentionPattern.exec(text);
+    }
+    if (userIds.size === 0) return text;
+    if (skipSelfMention && this._botUserId) {
+      userIds.delete(this._botUserId);
+    }
+    if (userIds.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);
+    return text.replace(/<@([A-Z0-9]+)(?:\|[^>]*)?>/g, (_m, uid) => {
+      const name = nameMap.get(uid);
+      return name ? `<@${uid}|${name}>` : `<@${uid}>`;
+    });
+  }
+  async parseSlackMessage(event, threadId, options) {
     const isMe = this.isMessageFromSelf(event);
-    const text = event.text || "";
+    const skipSelfMention = options?.skipSelfMention ?? true;
+    const rawText = event.text || "";
     let userName = event.username || "unknown";
     let fullName = event.username || "unknown";
     if (event.user && !event.username) {
@@ -1100,6 +1307,7 @@ var SlackAdapter = class _SlackAdapter {
       userName = userInfo.displayName;
       fullName = userInfo.realName;
     }
+    const text = await this.resolveInlineMentions(rawText, skipSelfMention);
     return new Message({
       id: event.ts || "",
       threadId,
@@ -1785,7 +1993,7 @@ var SlackAdapter = class _SlackAdapter {
   }
   decodeThreadId(threadId) {
     const parts = threadId.split(":");
-    if (parts.length !== 3 || parts[0] !== "slack") {
+    if (parts.length < 2 || parts.length > 3 || parts[0] !== "slack") {
       throw new ValidationError(
         "slack",
         `Invalid Slack thread ID: ${threadId}`
@@ -1793,7 +2001,7 @@ var SlackAdapter = class _SlackAdapter {
     }
     return {
       channel: parts[1],
-      threadTs: parts[2]
+      threadTs: parts.length === 3 ? parts[2] : ""
     };
   }
   parseMessage(raw) {
@@ -1837,6 +2045,221 @@ var SlackAdapter = class _SlackAdapter {
       )
     });
   }
+  // =========================================================================
+  // Channel-level methods
+  // =========================================================================
+  /**
+   * Derive channel ID from a Slack thread ID.
+   * Slack thread IDs are "slack:CHANNEL:THREAD_TS", channel ID is "slack:CHANNEL".
+   */
+  channelIdFromThreadId(threadId) {
+    const { channel } = this.decodeThreadId(threadId);
+    return `slack:${channel}`;
+  }
+  /**
+   * Fetch channel-level messages (conversations.history, not thread replies).
+   */
+  async fetchChannelMessages(channelId, options = {}) {
+    const channel = channelId.split(":")[1];
+    if (!channel) {
+      throw new ValidationError(
+        "slack",
+        `Invalid Slack channel ID: ${channelId}`
+      );
+    }
+    const direction = options.direction ?? "backward";
+    const limit = options.limit || 100;
+    try {
+      if (direction === "forward") {
+        return await this.fetchChannelMessagesForward(
+          channel,
+          limit,
+          options.cursor
+        );
+      }
+      return await this.fetchChannelMessagesBackward(
+        channel,
+        limit,
+        options.cursor
+      );
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async fetchChannelMessagesForward(channel, limit, cursor) {
+    this.logger.debug("Slack API: conversations.history (forward)", {
+      channel,
+      limit,
+      cursor
+    });
+    const result = await this.client.conversations.history(
+      this.withToken({
+        channel,
+        limit,
+        oldest: cursor,
+        inclusive: cursor ? false : void 0
+      })
+    );
+    const slackMessages = (result.messages || []).reverse();
+    const messages = await Promise.all(
+      slackMessages.map((msg) => {
+        const threadTs = msg.thread_ts || msg.ts || "";
+        const threadId = `slack:${channel}:${threadTs}`;
+        return this.parseSlackMessage(msg, threadId, {
+          skipSelfMention: false
+        });
+      })
+    );
+    let nextCursor;
+    if (result.has_more && slackMessages.length > 0) {
+      const newest = slackMessages[slackMessages.length - 1];
+      if (newest?.ts) {
+        nextCursor = newest.ts;
+      }
+    }
+    return {
+      messages,
+      nextCursor
+    };
+  }
+  async fetchChannelMessagesBackward(channel, limit, cursor) {
+    this.logger.debug("Slack API: conversations.history (backward)", {
+      channel,
+      limit,
+      cursor
+    });
+    const result = await this.client.conversations.history(
+      this.withToken({
+        channel,
+        limit,
+        latest: cursor,
+        inclusive: cursor ? false : void 0
+      })
+    );
+    const slackMessages = result.messages || [];
+    const chronological = [...slackMessages].reverse();
+    const messages = await Promise.all(
+      chronological.map((msg) => {
+        const threadTs = msg.thread_ts || msg.ts || "";
+        const threadId = `slack:${channel}:${threadTs}`;
+        return this.parseSlackMessage(msg, threadId, {
+          skipSelfMention: false
+        });
+      })
+    );
+    let nextCursor;
+    if (result.has_more && chronological.length > 0) {
+      const oldest = chronological[0];
+      if (oldest?.ts) {
+        nextCursor = oldest.ts;
+      }
+    }
+    return {
+      messages,
+      nextCursor
+    };
+  }
+  /**
+   * List threads in a Slack channel.
+   * Fetches channel history and filters for messages with replies.
+   */
+  async listThreads(channelId, options = {}) {
+    const channel = channelId.split(":")[1];
+    if (!channel) {
+      throw new ValidationError(
+        "slack",
+        `Invalid Slack channel ID: ${channelId}`
+      );
+    }
+    const limit = options.limit || 50;
+    try {
+      this.logger.debug("Slack API: conversations.history (listThreads)", {
+        channel,
+        limit,
+        cursor: options.cursor
+      });
+      const result = await this.client.conversations.history(
+        this.withToken({
+          channel,
+          limit: Math.min(limit * 3, 200),
+          // Fetch extra since not all have threads
+          cursor: options.cursor
+        })
+      );
+      const slackMessages = result.messages || [];
+      const threadMessages = slackMessages.filter(
+        (msg) => (msg.reply_count ?? 0) > 0
+      );
+      const selected = threadMessages.slice(0, limit);
+      const threads = await Promise.all(
+        selected.map(async (msg) => {
+          const threadTs = msg.ts || "";
+          const threadId = `slack:${channel}:${threadTs}`;
+          const rootMessage = await this.parseSlackMessage(msg, threadId, {
+            skipSelfMention: false
+          });
+          return {
+            id: threadId,
+            rootMessage,
+            replyCount: msg.reply_count,
+            lastReplyAt: msg.latest_reply ? new Date(Number.parseFloat(msg.latest_reply) * 1e3) : void 0
+          };
+        })
+      );
+      const nextCursor = result.response_metadata?.next_cursor;
+      return {
+        threads,
+        nextCursor: nextCursor || void 0
+      };
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  /**
+   * Fetch Slack channel info/metadata.
+   */
+  async fetchChannelInfo(channelId) {
+    const channel = channelId.split(":")[1];
+    if (!channel) {
+      throw new ValidationError(
+        "slack",
+        `Invalid Slack channel ID: ${channelId}`
+      );
+    }
+    try {
+      this.logger.debug("Slack API: conversations.info (channel)", { channel });
+      const result = await this.client.conversations.info(
+        this.withToken({ channel })
+      );
+      const info = result.channel;
+      return {
+        id: channelId,
+        name: info?.name ? `#${info.name}` : void 0,
+        isDM: info?.is_im || info?.is_mpim || false,
+        memberCount: info?.num_members,
+        metadata: {
+          purpose: info?.purpose?.value,
+          topic: info?.topic?.value
+        }
+      };
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  /**
+   * Post a top-level message to a channel (not in a thread).
+   */
+  async postChannelMessage(channelId, message) {
+    const channel = channelId.split(":")[1];
+    if (!channel) {
+      throw new ValidationError(
+        "slack",
+        `Invalid Slack channel ID: ${channelId}`
+      );
+    }
+    const syntheticThreadId = `slack:${channel}:`;
+    return this.postMessage(syntheticThreadId, message);
+  }
   renderFormatted(content) {
     return this.formatConverter.fromAst(content);
   }