@chat-adapter/slack 4.17.0 → 4.18.0

package/dist/index.d.ts

@@ -59,6 +59,12 @@ declare class SlackFormatConverter extends BaseFormatConverter {
      * Parse Slack mrkdwn into an AST.
      */
     toAst(mrkdwn: string): Root;
+    /**
+     * Convert AST to Slack blocks, using a native table block for the first table.
+     * Returns null if the AST contains no tables (caller should use regular text).
+     * Slack allows at most one table block per message; additional tables use ASCII.
+     */
+    toBlocksWithTable(ast: Root): SlackBlock[] | null;
     private nodeToMrkdwn;
 }
 
@@ -307,6 +313,11 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Includes a fetchData method that uses the bot token for auth.
      */
     private createAttachment;
+    /**
+     * 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>;
     openModal(triggerId: string, modal: ModalElement, contextId?: string): Promise<{

package/dist/index.js

@@ -17,6 +17,7 @@ import {
   defaultEmojiResolver,
   isJSX,
   Message,
+  parseMarkdown as parseMarkdown2,
   StreamingMarkdownRenderer,
   toModalElement
 } from "chat";
@@ -59,13 +60,14 @@ function cardToBlockKit(card) {
       alt_text: card.title || "Card image"
     });
   }
+  const state = { usedNativeTable: false };
   for (const child of card.children) {
-    const childBlocks = convertChildToBlocks(child);
+    const childBlocks = convertChildToBlocks(child, state);
     blocks.push(...childBlocks);
   }
   return blocks;
 }
-function convertChildToBlocks(child) {
+function convertChildToBlocks(child, state) {
   switch (child.type) {
     case "text":
       return [convertTextToBlock(child)];
@@ -76,13 +78,13 @@ function convertChildToBlocks(child) {
     case "actions":
       return [convertActionsToBlock(child)];
     case "section":
-      return convertSectionToBlocks(child);
+      return convertSectionToBlocks(child, state);
     case "fields":
       return [convertFieldsToBlock(child)];
     case "link":
       return [convertLinkToBlock(child)];
     case "table":
-      return convertTableToBlocks(child);
+      return convertTableToBlocks(child, state);
     default: {
       const text = cardChildToFallbackText(child);
       if (text) {
@@ -250,10 +252,10 @@ function convertRadioSelectToElement(radioSelect) {
   }
   return element;
 }
-function convertTableToBlocks(element) {
+function convertTableToBlocks(element, state) {
   const MAX_ROWS = 100;
   const MAX_COLS = 20;
-  if (element.rows.length > MAX_ROWS || element.headers.length > MAX_COLS) {
+  if (state.usedNativeTable || element.rows.length > MAX_ROWS || element.headers.length > MAX_COLS) {
     return [
       {
         type: "section",
@@ -266,31 +268,28 @@ ${tableElementToAscii(element.headers, element.rows)}
       }
     ];
   }
-  const columns = element.headers.map((header, i) => ({
-    id: `col_${i}`,
-    header: {
-      type: "plain_text",
-      text: convertEmoji(header)
-    }
+  state.usedNativeTable = true;
+  const headerRow = element.headers.map((header) => ({
+    type: "raw_text",
+    text: convertEmoji(header)
   }));
-  const rows = element.rows.map((row) => ({
-    cells: row.map((cell) => ({
-      type: "plain_text",
+  const dataRows = element.rows.map(
+    (row) => row.map((cell) => ({
+      type: "raw_text",
       text: convertEmoji(cell)
     }))
-  }));
+  );
   return [
     {
       type: "table",
-      columns,
-      rows
+      rows: [headerRow, ...dataRows]
     }
   ];
 }
-function convertSectionToBlocks(element) {
+function convertSectionToBlocks(element, state) {
   const blocks = [];
   for (const child of element.children) {
-    blocks.push(...convertChildToBlocks(child));
+    blocks.push(...convertChildToBlocks(child, state));
   }
   return blocks;
 }
@@ -428,16 +427,68 @@ var SlackFormatConverter = class extends BaseFormatConverter {
    */
   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(/<@([A-Z0-9_]+)\|([^>]+)>/g, "@$2");
+    markdown = markdown.replace(/<@([A-Z0-9_]+)>/g, "@$1");
+    markdown = markdown.replace(/<#[A-Z0-9_]+\|([^>]+)>/g, "#$1");
+    markdown = markdown.replace(/<#([A-Z0-9_]+)>/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);
   }
+  /**
+   * Convert AST to Slack blocks, using a native table block for the first table.
+   * Returns null if the AST contains no tables (caller should use regular text).
+   * Slack allows at most one table block per message; additional tables use ASCII.
+   */
+  toBlocksWithTable(ast) {
+    const hasTable = ast.children.some((node) => isTableNode(node));
+    if (!hasTable) {
+      return null;
+    }
+    const blocks = [];
+    let usedNativeTable = false;
+    let textBuffer = [];
+    const flushText = () => {
+      if (textBuffer.length > 0) {
+        const text = textBuffer.join("\n\n");
+        if (text.trim()) {
+          blocks.push({
+            type: "section",
+            text: { type: "mrkdwn", text }
+          });
+        }
+        textBuffer = [];
+      }
+    };
+    for (const child of ast.children) {
+      const node = child;
+      if (isTableNode(node)) {
+        flushText();
+        if (usedNativeTable) {
+          blocks.push({
+            type: "section",
+            text: {
+              type: "mrkdwn",
+              text: `\`\`\`
+${tableToAscii(node)}
+\`\`\``
+            }
+          });
+        } else {
+          blocks.push(
+            mdastTableToSlackBlock(node, this.nodeToMrkdwn.bind(this))
+          );
+          usedNativeTable = true;
+        }
+      } else {
+        textBuffer.push(this.nodeToMrkdwn(node));
+      }
+    }
+    flushText();
+    return blocks;
+  }
   nodeToMrkdwn(node) {
     if (isParagraphNode(node)) {
       return getNodeChildren(node).map((child) => this.nodeToMrkdwn(child)).join("");
@@ -489,6 +540,26 @@ ${tableToAscii(node)}
     return this.defaultNodeToText(node, (child) => this.nodeToMrkdwn(child));
   }
 };
+function mdastTableToSlackBlock(node, cellConverter) {
+  const rows = [];
+  for (const row of node.children) {
+    const cells = getNodeChildren(row).map((cell) => ({
+      type: "raw_text",
+      text: getNodeChildren(cell).map(cellConverter).join("")
+    }));
+    rows.push(cells);
+  }
+  const block = { type: "table", rows };
+  if (node.align) {
+    const columnSettings = node.align.map(
+      (a) => ({
+        align: a || "left"
+      })
+    );
+    block.column_settings = columnSettings;
+  }
+  return block;
+}
 
 // src/modals.ts
 function encodeModalMetadata(meta) {
@@ -636,6 +707,7 @@ function radioSelectToBlock(radioSelect) {
 }
 
 // src/index.ts
+var SLACK_USER_ID_PATTERN = /^[A-Z0-9_]+$/;
 var SlackAdapter = class _SlackAdapter {
   name = "slack";
   userName;
@@ -1569,12 +1641,22 @@ var SlackAdapter = class _SlackAdapter {
    *   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);
+    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 (userIds.size === 0) {
       return text;
@@ -1592,10 +1674,29 @@ var SlackAdapter = class _SlackAdapter {
       })
     );
     const nameMap = new Map(lookups);
-    return text.replace(/<@([A-Z0-9]+)(?:\|[^>]*)?>/g, (_m, uid) => {
-      const name = nameMap.get(uid);
-      return name ? `<@${uid}|${name}>` : `<@${uid}>`;
-    });
+    let result = "";
+    let remaining = text;
+    let startIdx = remaining.indexOf("<@");
+    while (startIdx !== -1) {
+      result += remaining.slice(0, startIdx);
+      remaining = remaining.slice(startIdx);
+      const endIdx = remaining.indexOf(">");
+      if (endIdx === -1) {
+        break;
+      }
+      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}>`;
+      } else {
+        result += remaining.slice(0, endIdx + 1);
+      }
+      remaining = remaining.slice(endIdx + 1);
+      startIdx = remaining.indexOf("<@");
+    }
+    return result + remaining;
   }
   async parseSlackMessage(event, threadId, options) {
     const isMe = this.isMessageFromSelf(event);
@@ -1672,6 +1773,32 @@ var SlackAdapter = class _SlackAdapter {
       } : void 0
     };
   }
+  /**
+   * Try to render a message using native Slack table blocks.
+   * Returns blocks + fallback text if the message contains tables, null otherwise.
+   */
+  renderWithTableBlocks(message) {
+    let ast = null;
+    if (typeof message === "object" && message !== null) {
+      if ("ast" in message) {
+        ast = message.ast;
+      } else if ("markdown" in message) {
+        ast = parseMarkdown2(message.markdown);
+      }
+    }
+    if (!ast) {
+      return null;
+    }
+    const blocks = this.formatConverter.toBlocksWithTable(ast);
+    if (!blocks) {
+      return null;
+    }
+    const fallbackText = convertEmojiPlaceholders(
+      this.formatConverter.renderPostable(message),
+      "slack"
+    );
+    return { text: fallbackText, blocks };
+  }
   async postMessage(threadId, message) {
     const { channel, threadTs } = this.decodeThreadId(threadId);
     try {
@@ -1718,6 +1845,33 @@ var SlackAdapter = class _SlackAdapter {
           raw: result2
         };
       }
+      const tableResult = this.renderWithTableBlocks(message);
+      if (tableResult) {
+        this.logger.debug("Slack API: chat.postMessage (table blocks)", {
+          channel,
+          threadTs,
+          blockCount: tableResult.blocks.length
+        });
+        const result2 = await this.client.chat.postMessage(
+          this.withToken({
+            channel,
+            thread_ts: threadTs,
+            text: tableResult.text,
+            blocks: tableResult.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 = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "slack"
@@ -1782,6 +1936,34 @@ var SlackAdapter = class _SlackAdapter {
           raw: result2
         };
       }
+      const tableResult = this.renderWithTableBlocks(message);
+      if (tableResult) {
+        this.logger.debug("Slack API: chat.postEphemeral (table blocks)", {
+          channel,
+          threadTs,
+          userId,
+          blockCount: tableResult.blocks.length
+        });
+        const result2 = await this.client.chat.postEphemeral(
+          this.withToken({
+            channel,
+            thread_ts: threadTs || void 0,
+            user: userId,
+            text: tableResult.text,
+            blocks: tableResult.blocks
+          })
+        );
+        this.logger.debug("Slack API: chat.postEphemeral response", {
+          messageTs: result2.message_ts,
+          ok: result2.ok
+        });
+        return {
+          id: result2.message_ts || "",
+          threadId,
+          usedFallback: false,
+          raw: result2
+        };
+      }
       const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "slack"
@@ -1958,6 +2140,31 @@ var SlackAdapter = class _SlackAdapter {
           raw: result2
         };
       }
+      const tableResult = this.renderWithTableBlocks(message);
+      if (tableResult) {
+        this.logger.debug("Slack API: chat.update (table blocks)", {
+          channel,
+          messageId,
+          blockCount: tableResult.blocks.length
+        });
+        const result2 = await this.client.chat.update(
+          this.withToken({
+            channel,
+            ts: messageId,
+            text: tableResult.text,
+            blocks: tableResult.blocks
+          })
+        );
+        this.logger.debug("Slack API: chat.update response", {
+          messageId: result2.ts,
+          ok: result2.ok
+        });
+        return {
+          id: result2.ts,
+          threadId,
+          raw: result2
+        };
+      }
       const text = convertEmojiPlaceholders(
         this.formatConverter.renderPostable(message),
         "slack"
@@ -2764,13 +2971,22 @@ var SlackAdapter = class _SlackAdapter {
           blocks: cardToBlockKit(card)
         };
       } else {
-        payload = {
-          replace_original: true,
-          text: convertEmojiPlaceholders(
-            this.formatConverter.renderPostable(message),
-            "slack"
-          )
-        };
+        const tableResult = this.renderWithTableBlocks(message);
+        if (tableResult) {
+          payload = {
+            replace_original: true,
+            text: tableResult.text,
+            blocks: tableResult.blocks
+          };
+        } else {
+          payload = {
+            replace_original: true,
+            text: convertEmojiPlaceholders(
+              this.formatConverter.renderPostable(message),
+              "slack"
+            )
+          };
+        }
       }
       if (options?.threadTs) {
         payload.thread_ts = options.threadTs;