@chat-adapter/slack 4.11.0 → 4.13.0

package/dist/index.js

@@ -854,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) {
@@ -909,6 +924,18 @@ var SlackAdapter = class _SlackAdapter {
         this.handleMessageEvent(slackEvent, options);
       } else if (event.type === "reaction_added" || event.type === "reaction_removed") {
         this.handleReactionEvent(event, options);
+      } else if (event.type === "assistant_thread_started") {
+        this.handleAssistantThreadStarted(
+          event,
+          options
+        );
+      } else if (event.type === "assistant_thread_context_changed") {
+        this.handleAssistantContextChanged(
+          event,
+          options
+        );
+      } else if (event.type === "app_home_opened" && event.tab === "home") {
+        this.handleAppHomeOpened(event, options);
       }
     }
   }
@@ -941,6 +968,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).
    */
@@ -952,20 +1019,18 @@ var SlackAdapter = class _SlackAdapter {
     const channel = payload.channel?.id || payload.container?.channel_id;
     const messageTs = payload.message?.ts || payload.container?.message_ts;
     const threadTs = payload.message?.thread_ts || payload.container?.thread_ts || messageTs;
-    if (!channel || !messageTs) {
-      this.logger.warn("Missing channel or message_ts in block_actions", {
-        channel,
-        messageTs
-      });
+    const isViewAction = payload.container?.type === "view";
+    if (!isViewAction && !channel) {
+      this.logger.warn("Missing channel in block_actions", { channel });
       return;
     }
-    const threadId = this.encodeThreadId({
+    const threadId = channel && (threadTs || messageTs) ? this.encodeThreadId({
       channel,
-      threadTs: threadTs || messageTs
-    });
+      threadTs: threadTs || messageTs || ""
+    }) : "";
     const isEphemeral = payload.container?.is_ephemeral === true;
     const responseUrl = payload.response_url;
-    const messageId = isEphemeral && responseUrl ? this.encodeEphemeralMessageId(messageTs, responseUrl, payload.user.id) : messageTs;
+    const messageId = isEphemeral && responseUrl && messageTs ? this.encodeEphemeralMessageId(messageTs, responseUrl, payload.user.id) : messageTs || "";
     for (const action of payload.actions) {
       const actionValue = action.selected_option?.value ?? action.value;
       const actionEvent = {
@@ -1149,17 +1214,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).
@@ -1203,9 +1271,196 @@ var SlackAdapter = class _SlackAdapter {
     };
     this.chat.processReaction({ ...reactionEvent, adapter: this }, options);
   }
-  async parseSlackMessage(event, threadId) {
+  /**
+   * Handle assistant_thread_started events from Slack's Assistants API.
+   * Fires when a user opens a new assistant thread (DM with the bot).
+   */
+  handleAssistantThreadStarted(event, options) {
+    if (!this.chat) {
+      this.logger.warn(
+        "Chat instance not initialized, ignoring assistant_thread_started"
+      );
+      return;
+    }
+    if (!event.assistant_thread) {
+      this.logger.warn(
+        "Malformed assistant_thread_started: missing assistant_thread"
+      );
+      return;
+    }
+    const { channel_id, thread_ts, user_id, context } = event.assistant_thread;
+    const threadId = this.encodeThreadId({
+      channel: channel_id,
+      threadTs: thread_ts
+    });
+    this.chat.processAssistantThreadStarted(
+      {
+        threadId,
+        userId: user_id,
+        channelId: channel_id,
+        threadTs: thread_ts,
+        context: {
+          channelId: context.channel_id,
+          teamId: context.team_id,
+          enterpriseId: context.enterprise_id,
+          threadEntryPoint: context.thread_entry_point,
+          forceSearch: context.force_search
+        },
+        adapter: this
+      },
+      options
+    );
+  }
+  /**
+   * Handle assistant_thread_context_changed events from Slack's Assistants API.
+   * Fires when a user navigates to a different channel with the assistant panel open.
+   */
+  handleAssistantContextChanged(event, options) {
+    if (!this.chat) {
+      this.logger.warn(
+        "Chat instance not initialized, ignoring assistant_thread_context_changed"
+      );
+      return;
+    }
+    if (!event.assistant_thread) {
+      this.logger.warn(
+        "Malformed assistant_thread_context_changed: missing assistant_thread"
+      );
+      return;
+    }
+    const { channel_id, thread_ts, user_id, context } = event.assistant_thread;
+    const threadId = this.encodeThreadId({
+      channel: channel_id,
+      threadTs: thread_ts
+    });
+    this.chat.processAssistantContextChanged(
+      {
+        threadId,
+        userId: user_id,
+        channelId: channel_id,
+        threadTs: thread_ts,
+        context: {
+          channelId: context.channel_id,
+          teamId: context.team_id,
+          enterpriseId: context.enterprise_id,
+          threadEntryPoint: context.thread_entry_point,
+          forceSearch: context.force_search
+        },
+        adapter: this
+      },
+      options
+    );
+  }
+  /**
+   * Handle app_home_opened events from Slack.
+   * Fires when a user opens the bot's Home tab.
+   */
+  handleAppHomeOpened(event, options) {
+    if (!this.chat) {
+      this.logger.warn(
+        "Chat instance not initialized, ignoring app_home_opened"
+      );
+      return;
+    }
+    this.chat.processAppHomeOpened(
+      {
+        userId: event.user,
+        channelId: event.channel,
+        adapter: this
+      },
+      options
+    );
+  }
+  /**
+   * Publish a Home tab view for a user.
+   * Slack API: views.publish
+   */
+  async publishHomeView(userId, view) {
+    await this.client.views.publish(
+      // biome-ignore lint/suspicious/noExplicitAny: view blocks are consumer-defined
+      this.withToken({ user_id: userId, view })
+    );
+  }
+  /**
+   * Set suggested prompts for an assistant thread.
+   * Slack Assistants API: assistant.threads.setSuggestedPrompts
+   */
+  async setSuggestedPrompts(channelId, threadTs, prompts, title) {
+    await this.client.assistant.threads.setSuggestedPrompts(
+      this.withToken({
+        channel_id: channelId,
+        thread_ts: threadTs,
+        prompts,
+        title
+      })
+    );
+  }
+  /**
+   * Set status/thinking indicator for an assistant thread.
+   * Slack Assistants API: assistant.threads.setStatus
+   */
+  async setAssistantStatus(channelId, threadTs, status, loadingMessages) {
+    await this.client.assistant.threads.setStatus(
+      this.withToken({
+        channel_id: channelId,
+        thread_ts: threadTs,
+        status,
+        ...loadingMessages && { loading_messages: loadingMessages }
+      })
+    );
+  }
+  /**
+   * Set title for an assistant thread (shown in History tab).
+   * Slack Assistants API: assistant.threads.setTitle
+   */
+  async setAssistantTitle(channelId, threadTs, title) {
+    await this.client.assistant.threads.setTitle(
+      this.withToken({
+        channel_id: channelId,
+        thread_ts: threadTs,
+        title
+      })
+    );
+  }
+  /**
+   * 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) {
@@ -1213,6 +1468,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,
@@ -1686,7 +1942,10 @@ var SlackAdapter = class _SlackAdapter {
         await streamer.append({ markdown_text: chunk });
       }
     }
-    const result = await streamer.stop();
+    const result = await streamer.stop(
+      // biome-ignore lint/suspicious/noExplicitAny: stopBlocks are platform-specific Block Kit elements
+      options?.stopBlocks ? { blocks: options.stopBlocks } : void 0
+    );
     const messageTs = result.message?.ts ?? result.ts;
     this.logger.debug("Slack: stream complete", { messageId: messageTs });
     return {
@@ -1898,7 +2157,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}`
@@ -1906,7 +2165,7 @@ var SlackAdapter = class _SlackAdapter {
     }
     return {
       channel: parts[1],
-      threadTs: parts[2]
+      threadTs: parts.length === 3 ? parts[2] : ""
     };
   }
   parseMessage(raw) {
@@ -1950,6 +2209,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);
   }