@chat-adapter/slack 4.0.0

package/dist/index.js

@@ -0,0 +1,1075 @@
+// src/index.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { WebClient } from "@slack/web-api";
+import {
+  convertEmojiPlaceholders as convertEmojiPlaceholders2,
+  defaultEmojiResolver,
+  isCardElement,
+  RateLimitError
+} from "chat";
+
+// src/cards.ts
+import {
+  convertEmojiPlaceholders
+} from "chat";
+function convertEmoji(text) {
+  return convertEmojiPlaceholders(text, "slack");
+}
+function cardToBlockKit(card) {
+  const blocks = [];
+  if (card.title) {
+    blocks.push({
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: convertEmoji(card.title),
+        emoji: true
+      }
+    });
+  }
+  if (card.subtitle) {
+    blocks.push({
+      type: "context",
+      elements: [
+        {
+          type: "mrkdwn",
+          text: convertEmoji(card.subtitle)
+        }
+      ]
+    });
+  }
+  if (card.imageUrl) {
+    blocks.push({
+      type: "image",
+      image_url: card.imageUrl,
+      alt_text: card.title || "Card image"
+    });
+  }
+  for (const child of card.children) {
+    const childBlocks = convertChildToBlocks(child);
+    blocks.push(...childBlocks);
+  }
+  return blocks;
+}
+function convertChildToBlocks(child) {
+  switch (child.type) {
+    case "text":
+      return [convertTextToBlock(child)];
+    case "image":
+      return [convertImageToBlock(child)];
+    case "divider":
+      return [convertDividerToBlock(child)];
+    case "actions":
+      return [convertActionsToBlock(child)];
+    case "section":
+      return convertSectionToBlocks(child);
+    case "fields":
+      return [convertFieldsToBlock(child)];
+    default:
+      return [];
+  }
+}
+function convertTextToBlock(element) {
+  const text = convertEmoji(element.content);
+  let formattedText = text;
+  if (element.style === "bold") {
+    formattedText = `*${text}*`;
+  } else if (element.style === "muted") {
+    return {
+      type: "context",
+      elements: [{ type: "mrkdwn", text }]
+    };
+  }
+  return {
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text: formattedText
+    }
+  };
+}
+function convertImageToBlock(element) {
+  return {
+    type: "image",
+    image_url: element.url,
+    alt_text: element.alt || "Image"
+  };
+}
+function convertDividerToBlock(_element) {
+  return { type: "divider" };
+}
+function convertActionsToBlock(element) {
+  const elements = element.children.map(
+    (button) => convertButtonToElement(button)
+  );
+  return {
+    type: "actions",
+    elements
+  };
+}
+function convertButtonToElement(button) {
+  const element = {
+    type: "button",
+    text: {
+      type: "plain_text",
+      text: convertEmoji(button.label),
+      emoji: true
+    },
+    action_id: button.id
+  };
+  if (button.value) {
+    element.value = button.value;
+  }
+  if (button.style === "primary") {
+    element.style = "primary";
+  } else if (button.style === "danger") {
+    element.style = "danger";
+  }
+  return element;
+}
+function convertSectionToBlocks(element) {
+  const blocks = [];
+  for (const child of element.children) {
+    blocks.push(...convertChildToBlocks(child));
+  }
+  return blocks;
+}
+function convertFieldsToBlock(element) {
+  const fields = [];
+  for (const field of element.children) {
+    fields.push({
+      type: "mrkdwn",
+      text: `*${convertEmoji(field.label)}*
+${convertEmoji(field.value)}`
+    });
+  }
+  return {
+    type: "section",
+    fields
+  };
+}
+function cardToFallbackText(card) {
+  const parts = [];
+  if (card.title) {
+    parts.push(`*${convertEmoji(card.title)}*`);
+  }
+  if (card.subtitle) {
+    parts.push(convertEmoji(card.subtitle));
+  }
+  for (const child of card.children) {
+    const text = childToFallbackText(child);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return parts.join("\n");
+}
+function childToFallbackText(child) {
+  switch (child.type) {
+    case "text":
+      return convertEmoji(child.content);
+    case "fields":
+      return child.children.map((f) => `${convertEmoji(f.label)}: ${convertEmoji(f.value)}`).join("\n");
+    case "actions":
+      return `[${child.children.map((b) => convertEmoji(b.label)).join("] [")}]`;
+    case "section":
+      return child.children.map((c) => childToFallbackText(c)).filter(Boolean).join("\n");
+    default:
+      return null;
+  }
+}
+
+// src/markdown.ts
+import {
+  BaseFormatConverter,
+  parseMarkdown
+} from "chat";
+var SlackFormatConverter = class extends BaseFormatConverter {
+  /**
+   * Convert @mentions to Slack format in plain text.
+   * @name → <@name>
+   */
+  convertMentionsToSlack(text) {
+    return text.replace(/@(\w+)/g, "<@$1>");
+  }
+  /**
+   * Override renderPostable to convert @mentions in plain strings.
+   */
+  renderPostable(message) {
+    if (typeof message === "string") {
+      return this.convertMentionsToSlack(message);
+    }
+    if ("raw" in message) {
+      return this.convertMentionsToSlack(message.raw);
+    }
+    if ("markdown" in message) {
+      return this.fromAst(parseMarkdown(message.markdown));
+    }
+    if ("ast" in message) {
+      return this.fromAst(message.ast);
+    }
+    return "";
+  }
+  /**
+   * Render an AST to Slack mrkdwn format.
+   */
+  fromAst(ast) {
+    const parts = [];
+    for (const node of ast.children) {
+      parts.push(this.nodeToMrkdwn(node));
+    }
+    return parts.join("\n\n");
+  }
+  /**
+   * Parse Slack mrkdwn into an AST.
+   */
+  toAst(mrkdwn) {
+    let markdown = mrkdwn;
+    markdown = markdown.replace(/<@([^|>]+)\|([^>]+)>/g, "@$2");
+    markdown = markdown.replace(/<@([^>]+)>/g, "@$1");
+    markdown = markdown.replace(/<#[^|>]+\|([^>]+)>/g, "#$1");
+    markdown = markdown.replace(/<#([^>]+)>/g, "#$1");
+    markdown = markdown.replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, "[$2]($1)");
+    markdown = markdown.replace(/<(https?:\/\/[^>]+)>/g, "$1");
+    markdown = markdown.replace(/(?<![_*\\])\*([^*\n]+)\*(?![_*])/g, "**$1**");
+    markdown = markdown.replace(/(?<!~)~([^~\n]+)~(?!~)/g, "~~$1~~");
+    return parseMarkdown(markdown);
+  }
+  nodeToMrkdwn(node) {
+    switch (node.type) {
+      case "paragraph":
+        return node.children.map((child) => this.nodeToMrkdwn(child)).join("");
+      case "text": {
+        const textValue = node.value;
+        return textValue.replace(/@(\w+)/g, "<@$1>");
+      }
+      case "strong":
+        return `*${node.children.map((child) => this.nodeToMrkdwn(child)).join("")}*`;
+      case "emphasis":
+        return `_${node.children.map((child) => this.nodeToMrkdwn(child)).join("")}_`;
+      case "delete":
+        return `~${node.children.map((child) => this.nodeToMrkdwn(child)).join("")}~`;
+      case "inlineCode":
+        return `\`${node.value}\``;
+      case "code": {
+        const codeNode = node;
+        return `\`\`\`${codeNode.lang || ""}
+${codeNode.value}
+\`\`\``;
+      }
+      case "link": {
+        const linkNode = node;
+        const linkText = linkNode.children.map((child) => this.nodeToMrkdwn(child)).join("");
+        return `<${linkNode.url}|${linkText}>`;
+      }
+      case "blockquote":
+        return node.children.map((child) => `> ${this.nodeToMrkdwn(child)}`).join("\n");
+      case "list":
+        return node.children.map((item, i) => {
+          const prefix = node.ordered ? `${i + 1}.` : "\u2022";
+          const content = item.children.map((child) => this.nodeToMrkdwn(child)).join("");
+          return `${prefix} ${content}`;
+        }).join("\n");
+      case "listItem":
+        return node.children.map((child) => this.nodeToMrkdwn(child)).join("");
+      case "break":
+        return "\n";
+      case "thematicBreak":
+        return "---";
+      default:
+        if ("children" in node && Array.isArray(node.children)) {
+          return node.children.map((child) => this.nodeToMrkdwn(child)).join("");
+        }
+        if ("value" in node) {
+          return String(node.value);
+        }
+        return "";
+    }
+  }
+};
+
+// src/index.ts
+var SlackAdapter = class _SlackAdapter {
+  name = "slack";
+  userName;
+  client;
+  signingSecret;
+  botToken;
+  chat = null;
+  logger = null;
+  _botUserId = null;
+  _botId = null;
+  // Bot app ID (B_xxx) - different from user ID
+  formatConverter = new SlackFormatConverter();
+  static USER_CACHE_TTL_MS = 60 * 60 * 1e3;
+  // 1 hour
+  /** Bot user ID (e.g., U_BOT_123) used for mention detection */
+  get botUserId() {
+    return this._botUserId || void 0;
+  }
+  constructor(config) {
+    this.client = new WebClient(config.botToken);
+    this.signingSecret = config.signingSecret;
+    this.botToken = config.botToken;
+    this.userName = config.userName || "bot";
+    this._botUserId = config.botUserId || null;
+  }
+  async initialize(chat) {
+    this.chat = chat;
+    this.logger = chat.getLogger(this.name);
+    if (!this._botUserId) {
+      try {
+        const authResult = await this.client.auth.test();
+        this._botUserId = authResult.user_id;
+        this._botId = authResult.bot_id || null;
+        if (authResult.user) {
+          this.userName = authResult.user;
+        }
+        this.logger.info("Slack auth completed", {
+          botUserId: this._botUserId,
+          botId: this._botId
+        });
+      } catch (error) {
+        this.logger.warn("Could not fetch bot user ID", { error });
+      }
+    }
+  }
+  /**
+   * Look up user info from Slack API with caching via state adapter.
+   * Returns display name and real name, or falls back to user ID.
+   */
+  async lookupUser(userId) {
+    const cacheKey = `slack:user:${userId}`;
+    if (this.chat) {
+      const cached = await this.chat.getState().get(cacheKey);
+      if (cached) {
+        return { displayName: cached.displayName, realName: cached.realName };
+      }
+    }
+    try {
+      const result = await this.client.users.info({ user: userId });
+      const user = result.user;
+      const displayName = user?.profile?.display_name || user?.profile?.real_name || user?.real_name || user?.name || userId;
+      const realName = user?.real_name || user?.profile?.real_name || displayName;
+      if (this.chat) {
+        await this.chat.getState().set(
+          cacheKey,
+          { displayName, realName },
+          _SlackAdapter.USER_CACHE_TTL_MS
+        );
+      }
+      this.logger?.debug("Fetched user info", {
+        userId,
+        displayName,
+        realName
+      });
+      return { displayName, realName };
+    } catch (error) {
+      this.logger?.warn("Could not fetch user info", { userId, error });
+      return { displayName: userId, realName: userId };
+    }
+  }
+  async handleWebhook(request, options) {
+    const body = await request.text();
+    this.logger?.debug("Slack webhook raw body", { body });
+    const timestamp = request.headers.get("x-slack-request-timestamp");
+    const signature = request.headers.get("x-slack-signature");
+    if (!this.verifySignature(body, timestamp, signature)) {
+      return new Response("Invalid signature", { status: 401 });
+    }
+    const contentType = request.headers.get("content-type") || "";
+    if (contentType.includes("application/x-www-form-urlencoded")) {
+      return this.handleInteractivePayload(body, options);
+    }
+    let payload;
+    try {
+      payload = JSON.parse(body);
+    } catch {
+      return new Response("Invalid JSON", { status: 400 });
+    }
+    if (payload.type === "url_verification" && payload.challenge) {
+      return new Response(JSON.stringify({ challenge: payload.challenge }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (payload.type === "event_callback" && payload.event) {
+      const event = payload.event;
+      if (event.type === "message" || event.type === "app_mention") {
+        this.handleMessageEvent(event, options);
+      } else if (event.type === "reaction_added" || event.type === "reaction_removed") {
+        this.handleReactionEvent(event, options);
+      }
+    }
+    return new Response("ok", { status: 200 });
+  }
+  /**
+   * Handle Slack interactive payloads (button clicks, etc.).
+   * These are sent as form-urlencoded with a `payload` JSON field.
+   */
+  handleInteractivePayload(body, options) {
+    const params = new URLSearchParams(body);
+    const payloadStr = params.get("payload");
+    if (!payloadStr) {
+      return new Response("Missing payload", { status: 400 });
+    }
+    let payload;
+    try {
+      payload = JSON.parse(payloadStr);
+    } catch {
+      return new Response("Invalid payload JSON", { status: 400 });
+    }
+    if (payload.type === "block_actions") {
+      this.handleBlockActions(payload, options);
+    }
+    return new Response("", { status: 200 });
+  }
+  /**
+   * Handle block_actions payload (button clicks in Block Kit).
+   */
+  handleBlockActions(payload, options) {
+    if (!this.chat) {
+      this.logger?.warn("Chat instance not initialized, ignoring action");
+      return;
+    }
+    const channel = payload.channel?.id || payload.container?.channel_id;
+    const messageTs = payload.message?.ts || payload.container?.message_ts;
+    const threadTs = payload.message?.thread_ts || messageTs;
+    if (!channel || !messageTs) {
+      this.logger?.warn("Missing channel or message_ts in block_actions", {
+        channel,
+        messageTs
+      });
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      channel,
+      threadTs: threadTs || messageTs
+    });
+    for (const action of payload.actions) {
+      const actionEvent = {
+        actionId: action.action_id,
+        value: action.value,
+        user: {
+          userId: payload.user.id,
+          userName: payload.user.username || payload.user.name || "unknown",
+          fullName: payload.user.name || payload.user.username || "unknown",
+          isBot: false,
+          isMe: false
+        },
+        messageId: messageTs,
+        threadId,
+        adapter: this,
+        raw: payload
+      };
+      this.logger?.debug("Processing Slack block action", {
+        actionId: action.action_id,
+        value: action.value,
+        messageId: messageTs,
+        threadId
+      });
+      this.chat.processAction(actionEvent, options);
+    }
+  }
+  verifySignature(body, timestamp, signature) {
+    if (!timestamp || !signature) {
+      return false;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - parseInt(timestamp, 10)) > 300) {
+      return false;
+    }
+    const sigBasestring = `v0:${timestamp}:${body}`;
+    const expectedSignature = "v0=" + createHmac("sha256", this.signingSecret).update(sigBasestring).digest("hex");
+    try {
+      return timingSafeEqual(
+        Buffer.from(signature),
+        Buffer.from(expectedSignature)
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Handle message events from Slack.
+   * Bot message filtering (isMe) is handled centrally by the Chat class.
+   */
+  handleMessageEvent(event, options) {
+    if (!this.chat) {
+      this.logger?.warn("Chat instance not initialized, ignoring event");
+      return;
+    }
+    if (event.subtype && event.subtype !== "bot_message") {
+      this.logger?.debug("Ignoring message subtype", {
+        subtype: event.subtype
+      });
+      return;
+    }
+    if (!event.channel || !event.ts) {
+      this.logger?.debug("Ignoring event without channel or ts", {
+        channel: event.channel,
+        ts: event.ts
+      });
+      return;
+    }
+    const isDM = event.channel_type === "im";
+    const threadTs = isDM ? "" : event.thread_ts || event.ts;
+    const threadId = this.encodeThreadId({
+      channel: event.channel,
+      threadTs
+    });
+    this.chat.processMessage(
+      this,
+      threadId,
+      () => this.parseSlackMessage(event, threadId),
+      options
+    );
+  }
+  /**
+   * Handle reaction events from Slack (reaction_added, reaction_removed).
+   */
+  handleReactionEvent(event, options) {
+    if (!this.chat) {
+      this.logger?.warn("Chat instance not initialized, ignoring reaction");
+      return;
+    }
+    if (event.item.type !== "message") {
+      this.logger?.debug("Ignoring reaction to non-message item", {
+        itemType: event.item.type
+      });
+      return;
+    }
+    const threadId = this.encodeThreadId({
+      channel: event.item.channel,
+      threadTs: event.item.ts
+    });
+    const messageId = event.item.ts;
+    const rawEmoji = event.reaction;
+    const normalizedEmoji = defaultEmojiResolver.fromSlack(rawEmoji);
+    const isMe = this._botUserId !== null && event.user === this._botUserId || this._botId !== null && event.user === this._botId;
+    const reactionEvent = {
+      emoji: normalizedEmoji,
+      rawEmoji,
+      added: event.type === "reaction_added",
+      user: {
+        userId: event.user,
+        userName: event.user,
+        // Will be resolved below if possible
+        fullName: event.user,
+        isBot: false,
+        // Users add reactions, not bots typically
+        isMe
+      },
+      messageId,
+      threadId,
+      raw: event
+    };
+    this.chat.processReaction({ ...reactionEvent, adapter: this }, options);
+  }
+  async parseSlackMessage(event, threadId) {
+    const isMe = this.isMessageFromSelf(event);
+    const text = event.text || "";
+    let userName = event.username || "unknown";
+    let fullName = event.username || "unknown";
+    if (event.user && !event.username) {
+      const userInfo = await this.lookupUser(event.user);
+      userName = userInfo.displayName;
+      fullName = userInfo.realName;
+    }
+    return {
+      id: event.ts || "",
+      threadId,
+      text: this.formatConverter.extractPlainText(text),
+      formatted: this.formatConverter.toAst(text),
+      raw: event,
+      author: {
+        userId: event.user || event.bot_id || "unknown",
+        userName,
+        fullName,
+        isBot: !!event.bot_id,
+        isMe
+      },
+      metadata: {
+        dateSent: new Date(parseFloat(event.ts || "0") * 1e3),
+        edited: !!event.edited,
+        editedAt: event.edited ? new Date(parseFloat(event.edited.ts) * 1e3) : void 0
+      },
+      attachments: (event.files || []).map(
+        (file) => this.createAttachment(file)
+      )
+    };
+  }
+  /**
+   * Create an Attachment object from a Slack file.
+   * Includes a fetchData method that uses the bot token for auth.
+   */
+  createAttachment(file) {
+    const url = file.url_private;
+    const botToken = this.botToken;
+    let type = "file";
+    if (file.mimetype?.startsWith("image/")) {
+      type = "image";
+    } else if (file.mimetype?.startsWith("video/")) {
+      type = "video";
+    } else if (file.mimetype?.startsWith("audio/")) {
+      type = "audio";
+    }
+    return {
+      type,
+      url,
+      name: file.name,
+      mimeType: file.mimetype,
+      size: file.size,
+      width: file.original_w,
+      height: file.original_h,
+      fetchData: url ? async () => {
+        const response = await fetch(url, {
+          headers: {
+            Authorization: `Bearer ${botToken}`
+          }
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Failed to fetch file: ${response.status} ${response.statusText}`
+          );
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+      } : void 0
+    };
+  }
+  async postMessage(threadId, message) {
+    const { channel, threadTs } = this.decodeThreadId(threadId);
+    try {
+      const files = this.extractFiles(message);
+      if (files.length > 0) {
+        await this.uploadFiles(files, channel, threadTs || void 0);
+        const hasText = typeof message === "string" || typeof message === "object" && message !== null && ("raw" in message || "markdown" in message || "ast" in message);
+        const card2 = this.extractCard(message);
+        if (!hasText && !card2) {
+          return {
+            id: `file-${Date.now()}`,
+            threadId,
+            raw: { files }
+          };
+        }
+      }
+      const card = this.extractCard(message);
+      if (card) {
+        const blocks = cardToBlockKit(card);
+        const fallbackText = cardToFallbackText(card);
+        this.logger?.debug("Slack API: chat.postMessage (blocks)", {
+          channel,
+          threadTs,
+          blockCount: blocks.length
+        });
+        const result2 = await this.client.chat.postMessage({
+          channel,
+          thread_ts: threadTs,
+          text: fallbackText,
+          // Fallback for notifications
+          blocks,
+          unfurl_links: false,
+          unfurl_media: false
+        });
+        this.logger?.debug("Slack API: chat.postMessage response", {
+          messageId: result2.ts,
+          ok: result2.ok
+        });
+        return {
+          id: result2.ts,
+          threadId,
+          raw: result2
+        };
+      }
+      const text = convertEmojiPlaceholders2(
+        this.formatConverter.renderPostable(message),
+        "slack"
+      );
+      this.logger?.debug("Slack API: chat.postMessage", {
+        channel,
+        threadTs,
+        textLength: text.length
+      });
+      const result = await this.client.chat.postMessage({
+        channel,
+        thread_ts: threadTs,
+        text,
+        unfurl_links: false,
+        unfurl_media: false
+      });
+      this.logger?.debug("Slack API: chat.postMessage response", {
+        messageId: result.ts,
+        ok: result.ok
+      });
+      return {
+        id: result.ts,
+        threadId,
+        raw: result
+      };
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  /**
+   * Extract card element from a PostableMessage if present.
+   */
+  extractCard(message) {
+    if (isCardElement(message)) {
+      return message;
+    }
+    if (typeof message === "object" && message !== null && "card" in message) {
+      return message.card;
+    }
+    return null;
+  }
+  /**
+   * Extract files from a PostableMessage if present.
+   */
+  extractFiles(message) {
+    if (typeof message === "object" && message !== null && "files" in message) {
+      return message.files ?? [];
+    }
+    return [];
+  }
+  /**
+   * Upload files to Slack and share them to a channel.
+   * Returns the file IDs of uploaded files.
+   */
+  async uploadFiles(files, channel, threadTs) {
+    const fileIds = [];
+    for (const file of files) {
+      try {
+        let fileBuffer;
+        if (Buffer.isBuffer(file.data)) {
+          fileBuffer = file.data;
+        } else if (file.data instanceof ArrayBuffer) {
+          fileBuffer = Buffer.from(file.data);
+        } else if (file.data instanceof Blob) {
+          const arrayBuffer = await file.data.arrayBuffer();
+          fileBuffer = Buffer.from(arrayBuffer);
+        } else {
+          throw new Error("Unsupported file data type");
+        }
+        this.logger?.debug("Slack API: files.uploadV2", {
+          filename: file.filename,
+          size: fileBuffer.length,
+          mimeType: file.mimeType
+        });
+        const uploadArgs = {
+          channel_id: channel,
+          filename: file.filename,
+          file: fileBuffer
+        };
+        if (threadTs) {
+          uploadArgs.thread_ts = threadTs;
+        }
+        const result = await this.client.files.uploadV2(uploadArgs);
+        this.logger?.debug("Slack API: files.uploadV2 response", {
+          ok: result.ok
+        });
+        if (result.files && Array.isArray(result.files)) {
+          for (const uploadedFile of result.files) {
+            if (uploadedFile.id) {
+              fileIds.push(uploadedFile.id);
+            }
+          }
+        }
+      } catch (error) {
+        this.logger?.error("Failed to upload file", {
+          filename: file.filename,
+          error
+        });
+        throw error;
+      }
+    }
+    return fileIds;
+  }
+  async editMessage(threadId, messageId, message) {
+    const { channel } = this.decodeThreadId(threadId);
+    try {
+      const card = this.extractCard(message);
+      if (card) {
+        const blocks = cardToBlockKit(card);
+        const fallbackText = cardToFallbackText(card);
+        this.logger?.debug("Slack API: chat.update (blocks)", {
+          channel,
+          messageId,
+          blockCount: blocks.length
+        });
+        const result2 = await this.client.chat.update({
+          channel,
+          ts: messageId,
+          text: fallbackText,
+          blocks
+        });
+        this.logger?.debug("Slack API: chat.update response", {
+          messageId: result2.ts,
+          ok: result2.ok
+        });
+        return {
+          id: result2.ts,
+          threadId,
+          raw: result2
+        };
+      }
+      const text = convertEmojiPlaceholders2(
+        this.formatConverter.renderPostable(message),
+        "slack"
+      );
+      this.logger?.debug("Slack API: chat.update", {
+        channel,
+        messageId,
+        textLength: text.length
+      });
+      const result = await this.client.chat.update({
+        channel,
+        ts: messageId,
+        text
+      });
+      this.logger?.debug("Slack API: chat.update response", {
+        messageId: result.ts,
+        ok: result.ok
+      });
+      return {
+        id: result.ts,
+        threadId,
+        raw: result
+      };
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async deleteMessage(threadId, messageId) {
+    const { channel } = this.decodeThreadId(threadId);
+    try {
+      this.logger?.debug("Slack API: chat.delete", { channel, messageId });
+      await this.client.chat.delete({
+        channel,
+        ts: messageId
+      });
+      this.logger?.debug("Slack API: chat.delete response", { ok: true });
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async addReaction(threadId, messageId, emoji) {
+    const { channel } = this.decodeThreadId(threadId);
+    const slackEmoji = defaultEmojiResolver.toSlack(emoji);
+    const name = slackEmoji.replace(/:/g, "");
+    try {
+      this.logger?.debug("Slack API: reactions.add", {
+        channel,
+        messageId,
+        emoji: name
+      });
+      await this.client.reactions.add({
+        channel,
+        timestamp: messageId,
+        name
+      });
+      this.logger?.debug("Slack API: reactions.add response", { ok: true });
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async removeReaction(threadId, messageId, emoji) {
+    const { channel } = this.decodeThreadId(threadId);
+    const slackEmoji = defaultEmojiResolver.toSlack(emoji);
+    const name = slackEmoji.replace(/:/g, "");
+    try {
+      this.logger?.debug("Slack API: reactions.remove", {
+        channel,
+        messageId,
+        emoji: name
+      });
+      await this.client.reactions.remove({
+        channel,
+        timestamp: messageId,
+        name
+      });
+      this.logger?.debug("Slack API: reactions.remove response", { ok: true });
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async startTyping(_threadId) {
+  }
+  /**
+   * Open a direct message conversation with a user.
+   * Returns a thread ID that can be used to post messages.
+   */
+  async openDM(userId) {
+    try {
+      this.logger?.debug("Slack API: conversations.open", { userId });
+      const result = await this.client.conversations.open({ users: userId });
+      if (!result.channel?.id) {
+        throw new Error("Failed to open DM - no channel returned");
+      }
+      const channelId = result.channel.id;
+      this.logger?.debug("Slack API: conversations.open response", {
+        channelId,
+        ok: result.ok
+      });
+      return this.encodeThreadId({
+        channel: channelId,
+        threadTs: ""
+        // Empty threadTs indicates top-level channel messages
+      });
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async fetchMessages(threadId, options = {}) {
+    const { channel, threadTs } = this.decodeThreadId(threadId);
+    try {
+      this.logger?.debug("Slack API: conversations.replies", {
+        channel,
+        threadTs,
+        limit: options.limit || 100
+      });
+      const result = await this.client.conversations.replies({
+        channel,
+        ts: threadTs,
+        limit: options.limit || 100,
+        cursor: options.before
+      });
+      const messages = result.messages || [];
+      this.logger?.debug("Slack API: conversations.replies response", {
+        messageCount: messages.length,
+        ok: result.ok
+      });
+      return messages.map((msg) => this.parseSlackMessageSync(msg, threadId));
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  async fetchThread(threadId) {
+    const { channel, threadTs } = this.decodeThreadId(threadId);
+    try {
+      this.logger?.debug("Slack API: conversations.info", { channel });
+      const result = await this.client.conversations.info({ channel });
+      const channelInfo = result.channel;
+      this.logger?.debug("Slack API: conversations.info response", {
+        channelName: channelInfo?.name,
+        ok: result.ok
+      });
+      return {
+        id: threadId,
+        channelId: channel,
+        channelName: channelInfo?.name,
+        metadata: {
+          threadTs,
+          channel: result.channel
+        }
+      };
+    } catch (error) {
+      this.handleSlackError(error);
+    }
+  }
+  encodeThreadId(platformData) {
+    return `slack:${platformData.channel}:${platformData.threadTs}`;
+  }
+  /**
+   * Check if a thread is a direct message conversation.
+   * Slack DM channel IDs start with 'D'.
+   */
+  isDM(threadId) {
+    const { channel } = this.decodeThreadId(threadId);
+    return channel.startsWith("D");
+  }
+  decodeThreadId(threadId) {
+    const parts = threadId.split(":");
+    if (parts.length !== 3 || parts[0] !== "slack") {
+      throw new Error(`Invalid Slack thread ID: ${threadId}`);
+    }
+    return {
+      channel: parts[1],
+      threadTs: parts[2]
+    };
+  }
+  parseMessage(raw) {
+    const event = raw;
+    const threadTs = event.thread_ts || event.ts || "";
+    const threadId = this.encodeThreadId({
+      channel: event.channel || "",
+      threadTs
+    });
+    return this.parseSlackMessageSync(event, threadId);
+  }
+  /**
+   * Synchronous message parsing without user lookup.
+   * Used for parseMessage interface - falls back to user ID for username.
+   */
+  parseSlackMessageSync(event, threadId) {
+    const isMe = this.isMessageFromSelf(event);
+    const text = event.text || "";
+    const userName = event.username || event.user || "unknown";
+    const fullName = event.username || event.user || "unknown";
+    return {
+      id: event.ts || "",
+      threadId,
+      text: this.formatConverter.extractPlainText(text),
+      formatted: this.formatConverter.toAst(text),
+      raw: event,
+      author: {
+        userId: event.user || event.bot_id || "unknown",
+        userName,
+        fullName,
+        isBot: !!event.bot_id,
+        isMe
+      },
+      metadata: {
+        dateSent: new Date(parseFloat(event.ts || "0") * 1e3),
+        edited: !!event.edited,
+        editedAt: event.edited ? new Date(parseFloat(event.edited.ts) * 1e3) : void 0
+      },
+      attachments: (event.files || []).map(
+        (file) => this.createAttachment(file)
+      )
+    };
+  }
+  renderFormatted(content) {
+    return this.formatConverter.fromAst(content);
+  }
+  /**
+   * Check if a Slack event is from this bot.
+   *
+   * Slack messages can come from:
+   * - User messages: have `user` field (U_xxx format)
+   * - Bot messages: have `bot_id` field (B_xxx format)
+   *
+   * We check both because:
+   * - _botUserId is the user ID (U_xxx) - matches event.user
+   * - _botId is the bot ID (B_xxx) - matches event.bot_id
+   */
+  isMessageFromSelf(event) {
+    if (this._botUserId && event.user === this._botUserId) {
+      return true;
+    }
+    if (this._botId && event.bot_id === this._botId) {
+      return true;
+    }
+    return false;
+  }
+  handleSlackError(error) {
+    const slackError = error;
+    if (slackError.code === "slack_webapi_platform_error") {
+      if (slackError.data?.error === "ratelimited") {
+        throw new RateLimitError("Slack rate limit exceeded", void 0, error);
+      }
+    }
+    throw error;
+  }
+};
+function createSlackAdapter(config) {
+  return new SlackAdapter(config);
+}
+export {
+  SlackAdapter,
+  SlackFormatConverter,
+  SlackFormatConverter as SlackMarkdownConverter,
+  cardToBlockKit,
+  cardToFallbackText,
+  createSlackAdapter
+};
+//# sourceMappingURL=index.js.map