@chat-adapter/slack 4.8.0 → 4.9.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/index.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { createHmac, timingSafeEqual } from "crypto";
 import {
   AdapterRateLimitError,
@@ -185,6 +186,57 @@ function cardToFallbackText(card) {
   });
 }
 
+// src/crypto.ts
+import crypto from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var AUTH_TAG_LENGTH = 16;
+function encryptToken(plaintext, key) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const ciphertext = Buffer.concat([
+    cipher.update(plaintext, "utf8"),
+    cipher.final()
+  ]);
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("base64"),
+    data: ciphertext.toString("base64"),
+    tag: tag.toString("base64")
+  };
+}
+function decryptToken(encrypted, key) {
+  const iv = Buffer.from(encrypted.iv, "base64");
+  const ciphertext = Buffer.from(encrypted.data, "base64");
+  const tag = Buffer.from(encrypted.tag, "base64");
+  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(tag);
+  return Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]).toString("utf8");
+}
+function isEncryptedTokenData(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.iv === "string" && typeof obj.data === "string" && typeof obj.tag === "string";
+}
+function decodeKey(rawKey) {
+  const trimmed = rawKey.trim();
+  const isHex = /^[0-9a-fA-F]{64}$/.test(trimmed);
+  const key = Buffer.from(trimmed, isHex ? "hex" : "base64");
+  if (key.length !== 32) {
+    throw new Error(
+      `Encryption key must decode to exactly 32 bytes (received ${key.length}). Use a 64-char hex string or 44-char base64 string.`
+    );
+  }
+  return key;
+}
+
 // src/markdown.ts
 import {
   BaseFormatConverter,
@@ -393,7 +445,7 @@ var SlackAdapter = class _SlackAdapter {
   userName;
   client;
   signingSecret;
-  botToken;
+  defaultBotToken;
   chat = null;
   logger;
   _botUserId = null;
@@ -402,23 +454,56 @@ var SlackAdapter = class _SlackAdapter {
   formatConverter = new SlackFormatConverter();
   static USER_CACHE_TTL_MS = 60 * 60 * 1e3;
   // 1 hour
+  // Multi-workspace support
+  clientId;
+  clientSecret;
+  encryptionKey;
+  requestContext = new AsyncLocalStorage();
   /** Bot user ID (e.g., U_BOT_123) used for mention detection */
   get botUserId() {
+    const ctx = this.requestContext.getStore();
+    if (ctx?.botUserId) return ctx.botUserId;
     return this._botUserId || void 0;
   }
   constructor(config) {
     this.client = new WebClient(config.botToken);
     this.signingSecret = config.signingSecret;
-    this.botToken = config.botToken;
+    this.defaultBotToken = config.botToken;
     this.logger = config.logger;
     this.userName = config.userName || "bot";
     this._botUserId = config.botUserId || null;
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    if (config.encryptionKey) {
+      this.encryptionKey = decodeKey(config.encryptionKey);
+    }
+  }
+  /**
+   * Get the current bot token for API calls.
+   * Checks request context (multi-workspace) → default token (single-workspace) → throws.
+   */
+  getToken() {
+    const ctx = this.requestContext.getStore();
+    if (ctx?.token) return ctx.token;
+    if (this.defaultBotToken) return this.defaultBotToken;
+    throw new ChatError(
+      "No bot token available. In multi-workspace mode, ensure the webhook is being processed.",
+      "MISSING_BOT_TOKEN"
+    );
+  }
+  /**
+   * Add the current token to API call options.
+   * Workaround for Slack WebClient types not including `token` in per-method args.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: Slack types don't include token in method args
+  withToken(options) {
+    return { ...options, token: this.getToken() };
   }
   async initialize(chat) {
     this.chat = chat;
-    if (!this._botUserId) {
+    if (this.defaultBotToken && !this._botUserId) {
       try {
-        const authResult = await this.client.auth.test();
+        const authResult = await this.client.auth.test(this.withToken({}));
         this._botUserId = authResult.user_id;
         this._botId = authResult.bot_id || null;
         if (authResult.user) {
@@ -432,6 +517,165 @@ var SlackAdapter = class _SlackAdapter {
         this.logger.warn("Could not fetch bot user ID", { error });
       }
     }
+    if (!this.defaultBotToken) {
+      this.logger.info("Slack adapter initialized in multi-workspace mode");
+    }
+  }
+  // ===========================================================================
+  // Multi-workspace installation management
+  // ===========================================================================
+  installationKey(teamId) {
+    return `slack:installation:${teamId}`;
+  }
+  /**
+   * Save a Slack workspace installation.
+   * Call this from your OAuth callback route after a successful installation.
+   */
+  async setInstallation(teamId, installation) {
+    if (!this.chat) {
+      throw new ChatError(
+        "Adapter not initialized. Ensure chat.initialize() has been called first.",
+        "NOT_INITIALIZED"
+      );
+    }
+    const state = this.chat.getState();
+    const key = this.installationKey(teamId);
+    const dataToStore = this.encryptionKey ? {
+      ...installation,
+      botToken: encryptToken(installation.botToken, this.encryptionKey)
+    } : installation;
+    await state.set(key, dataToStore);
+    this.logger.info("Slack installation saved", {
+      teamId,
+      teamName: installation.teamName
+    });
+  }
+  /**
+   * Retrieve a Slack workspace installation.
+   */
+  async getInstallation(teamId) {
+    if (!this.chat) {
+      throw new ChatError(
+        "Adapter not initialized. Ensure chat.initialize() has been called first.",
+        "NOT_INITIALIZED"
+      );
+    }
+    const state = this.chat.getState();
+    const key = this.installationKey(teamId);
+    const stored = await state.get(key);
+    if (!stored) return null;
+    if (this.encryptionKey && isEncryptedTokenData(stored.botToken)) {
+      return {
+        ...stored,
+        botToken: decryptToken(
+          stored.botToken,
+          this.encryptionKey
+        )
+      };
+    }
+    return stored;
+  }
+  /**
+   * Handle the Slack OAuth V2 callback.
+   * Accepts the incoming request, extracts the authorization code,
+   * exchanges it for tokens, and saves the installation.
+   */
+  async handleOAuthCallback(request) {
+    if (!this.clientId || !this.clientSecret) {
+      throw new ChatError(
+        "clientId and clientSecret are required for OAuth. Pass them in createSlackAdapter().",
+        "MISSING_OAUTH_CONFIG"
+      );
+    }
+    const url = new URL(request.url);
+    const code = url.searchParams.get("code");
+    if (!code) {
+      throw new ChatError(
+        "Missing 'code' query parameter in OAuth callback request.",
+        "MISSING_OAUTH_CODE"
+      );
+    }
+    const redirectUri = url.searchParams.get("redirect_uri") ?? void 0;
+    const result = await this.client.oauth.v2.access({
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      code,
+      redirect_uri: redirectUri
+    });
+    if (!result.ok || !result.access_token || !result.team?.id) {
+      throw new ChatError(
+        `Slack OAuth failed: ${result.error || "missing access_token or team.id"}`,
+        "OAUTH_FAILED"
+      );
+    }
+    const teamId = result.team.id;
+    const installation = {
+      botToken: result.access_token,
+      botUserId: result.bot_user_id,
+      teamName: result.team.name
+    };
+    await this.setInstallation(teamId, installation);
+    return { teamId, installation };
+  }
+  /**
+   * Remove a Slack workspace installation.
+   */
+  async deleteInstallation(teamId) {
+    if (!this.chat) {
+      throw new ChatError(
+        "Adapter not initialized. Ensure chat.initialize() has been called first.",
+        "NOT_INITIALIZED"
+      );
+    }
+    const state = this.chat.getState();
+    await state.delete(this.installationKey(teamId));
+    this.logger.info("Slack installation deleted", { teamId });
+  }
+  /**
+   * Run a function with a specific bot token in context.
+   * Use this for operations outside webhook handling (cron jobs, workflows).
+   */
+  withBotToken(token, fn) {
+    return this.requestContext.run({ token }, fn);
+  }
+  // ===========================================================================
+  // Private helpers
+  // ===========================================================================
+  /**
+   * Resolve the bot token for a team from the state adapter.
+   */
+  async resolveTokenForTeam(teamId) {
+    try {
+      const installation = await this.getInstallation(teamId);
+      if (installation) {
+        return {
+          token: installation.botToken,
+          botUserId: installation.botUserId
+        };
+      }
+      this.logger.warn("No installation found for team", { teamId });
+      return null;
+    } catch (error) {
+      this.logger.error("Failed to resolve token for team", {
+        teamId,
+        error
+      });
+      return null;
+    }
+  }
+  /**
+   * Extract team_id from an interactive payload (form-urlencoded).
+   */
+  extractTeamIdFromInteractive(body) {
+    try {
+      const params = new URLSearchParams(body);
+      const payloadStr = params.get("payload");
+      if (!payloadStr) return null;
+      const payload = JSON.parse(payloadStr);
+      return payload.team?.id || payload.team_id || null;
+    } catch {
+      return null;
+    }
   }
   /**
    * Look up user info from Slack API with caching via state adapter.
@@ -446,7 +690,9 @@ var SlackAdapter = class _SlackAdapter {
       }
     }
     try {
-      const result = await this.client.users.info({ user: userId });
+      const result = await this.client.users.info(
+        this.withToken({ 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;
@@ -478,6 +724,19 @@ var SlackAdapter = class _SlackAdapter {
     }
     const contentType = request.headers.get("content-type") || "";
     if (contentType.includes("application/x-www-form-urlencoded")) {
+      if (!this.defaultBotToken) {
+        const teamId = this.extractTeamIdFromInteractive(body);
+        if (teamId) {
+          const ctx = await this.resolveTokenForTeam(teamId);
+          if (ctx) {
+            return this.requestContext.run(
+              ctx,
+              () => this.handleInteractivePayload(body, options)
+            );
+          }
+        }
+        this.logger.warn("Could not resolve token for interactive payload");
+      }
       return this.handleInteractivePayload(body, options);
     }
     let payload;
@@ -491,6 +750,25 @@ var SlackAdapter = class _SlackAdapter {
         headers: { "Content-Type": "application/json" }
       });
     }
+    if (!this.defaultBotToken && payload.type === "event_callback") {
+      const teamId = payload.team_id;
+      if (teamId) {
+        const ctx = await this.resolveTokenForTeam(teamId);
+        if (ctx) {
+          return this.requestContext.run(ctx, () => {
+            this.processEventPayload(payload, options);
+            return new Response("ok", { status: 200 });
+          });
+        }
+        this.logger.warn("Could not resolve token for team", { teamId });
+        return new Response("ok", { status: 200 });
+      }
+    }
+    this.processEventPayload(payload, options);
+    return new Response("ok", { status: 200 });
+  }
+  /** Extract and dispatch events from a validated payload */
+  processEventPayload(payload, options) {
     if (payload.type === "event_callback" && payload.event) {
       const event = payload.event;
       if (event.type === "message" || event.type === "app_mention") {
@@ -503,7 +781,6 @@ var SlackAdapter = class _SlackAdapter {
         this.handleReactionEvent(event, options);
       }
     }
-    return new Response("ok", { status: 200 });
   }
   /**
    * Handle Slack interactive payloads (button clicks, view submissions, etc.).
@@ -757,7 +1034,8 @@ var SlackAdapter = class _SlackAdapter {
     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 ctx = this.requestContext.getStore();
+    const isMe = ctx?.botUserId && event.user === ctx.botUserId || this._botUserId !== null && event.user === this._botUserId || this._botId !== null && event.user === this._botId;
     const reactionEvent = {
       emoji: normalizedEmoji,
       rawEmoji,
@@ -816,7 +1094,7 @@ var SlackAdapter = class _SlackAdapter {
    */
   createAttachment(file) {
     const url = file.url_private;
-    const botToken = this.botToken;
+    const botToken = this.getToken();
     let type = "file";
     if (file.mimetype?.startsWith("image/")) {
       type = "image";
@@ -875,15 +1153,17 @@ var SlackAdapter = class _SlackAdapter {
           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
-        });
+        const result2 = await this.client.chat.postMessage(
+          this.withToken({
+            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
@@ -903,13 +1183,15 @@ var SlackAdapter = class _SlackAdapter {
         threadTs,
         textLength: text.length
       });
-      const result = await this.client.chat.postMessage({
-        channel,
-        thread_ts: threadTs,
-        text,
-        unfurl_links: false,
-        unfurl_media: false
-      });
+      const result = await this.client.chat.postMessage(
+        this.withToken({
+          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
@@ -936,13 +1218,15 @@ var SlackAdapter = class _SlackAdapter {
           userId,
           blockCount: blocks.length
         });
-        const result2 = await this.client.chat.postEphemeral({
-          channel,
-          thread_ts: threadTs || void 0,
-          user: userId,
-          text: fallbackText,
-          blocks
-        });
+        const result2 = await this.client.chat.postEphemeral(
+          this.withToken({
+            channel,
+            thread_ts: threadTs || void 0,
+            user: userId,
+            text: fallbackText,
+            blocks
+          })
+        );
         this.logger.debug("Slack API: chat.postEphemeral response", {
           messageTs: result2.message_ts,
           ok: result2.ok
@@ -964,12 +1248,14 @@ var SlackAdapter = class _SlackAdapter {
         userId,
         textLength: text.length
       });
-      const result = await this.client.chat.postEphemeral({
-        channel,
-        thread_ts: threadTs || void 0,
-        user: userId,
-        text
-      });
+      const result = await this.client.chat.postEphemeral(
+        this.withToken({
+          channel,
+          thread_ts: threadTs || void 0,
+          user: userId,
+          text
+        })
+      );
       this.logger.debug("Slack API: chat.postEphemeral response", {
         messageTs: result.message_ts,
         ok: result.ok
@@ -991,10 +1277,12 @@ var SlackAdapter = class _SlackAdapter {
       callbackId: modal.callbackId
     });
     try {
-      const result = await this.client.views.open({
-        trigger_id: triggerId,
-        view
-      });
+      const result = await this.client.views.open(
+        this.withToken({
+          trigger_id: triggerId,
+          view
+        })
+      );
       this.logger.debug("Slack API: views.open response", {
         viewId: result.view?.id,
         ok: result.ok
@@ -1011,10 +1299,12 @@ var SlackAdapter = class _SlackAdapter {
       callbackId: modal.callbackId
     });
     try {
-      const result = await this.client.views.update({
-        view_id: viewId,
-        view
-      });
+      const result = await this.client.views.update(
+        this.withToken({
+          view_id: viewId,
+          view
+        })
+      );
       this.logger.debug("Slack API: views.update response", {
         viewId: result.view?.id,
         ok: result.ok
@@ -1049,6 +1339,7 @@ var SlackAdapter = class _SlackAdapter {
         if (threadTs) {
           uploadArgs.thread_ts = threadTs;
         }
+        uploadArgs.token = this.getToken();
         const result = await this.client.files.uploadV2(uploadArgs);
         this.logger.debug("Slack API: files.uploadV2 response", {
           ok: result.ok
@@ -1082,12 +1373,14 @@ var SlackAdapter = class _SlackAdapter {
           messageId,
           blockCount: blocks.length
         });
-        const result2 = await this.client.chat.update({
-          channel,
-          ts: messageId,
-          text: fallbackText,
-          blocks
-        });
+        const result2 = await this.client.chat.update(
+          this.withToken({
+            channel,
+            ts: messageId,
+            text: fallbackText,
+            blocks
+          })
+        );
         this.logger.debug("Slack API: chat.update response", {
           messageId: result2.ts,
           ok: result2.ok
@@ -1107,11 +1400,13 @@ var SlackAdapter = class _SlackAdapter {
         messageId,
         textLength: text.length
       });
-      const result = await this.client.chat.update({
-        channel,
-        ts: messageId,
-        text
-      });
+      const result = await this.client.chat.update(
+        this.withToken({
+          channel,
+          ts: messageId,
+          text
+        })
+      );
       this.logger.debug("Slack API: chat.update response", {
         messageId: result.ts,
         ok: result.ok
@@ -1129,10 +1424,12 @@ var SlackAdapter = class _SlackAdapter {
     const { channel } = this.decodeThreadId(threadId);
     try {
       this.logger.debug("Slack API: chat.delete", { channel, messageId });
-      await this.client.chat.delete({
-        channel,
-        ts: messageId
-      });
+      await this.client.chat.delete(
+        this.withToken({
+          channel,
+          ts: messageId
+        })
+      );
       this.logger.debug("Slack API: chat.delete response", { ok: true });
     } catch (error) {
       this.handleSlackError(error);
@@ -1148,11 +1445,13 @@ var SlackAdapter = class _SlackAdapter {
         messageId,
         emoji: name
       });
-      await this.client.reactions.add({
-        channel,
-        timestamp: messageId,
-        name
-      });
+      await this.client.reactions.add(
+        this.withToken({
+          channel,
+          timestamp: messageId,
+          name
+        })
+      );
       this.logger.debug("Slack API: reactions.add response", { ok: true });
     } catch (error) {
       this.handleSlackError(error);
@@ -1168,11 +1467,13 @@ var SlackAdapter = class _SlackAdapter {
         messageId,
         emoji: name
       });
-      await this.client.reactions.remove({
-        channel,
-        timestamp: messageId,
-        name
-      });
+      await this.client.reactions.remove(
+        this.withToken({
+          channel,
+          timestamp: messageId,
+          name
+        })
+      );
       this.logger.debug("Slack API: reactions.remove response", { ok: true });
     } catch (error) {
       this.handleSlackError(error);
@@ -1195,14 +1496,21 @@ var SlackAdapter = class _SlackAdapter {
     }
     const { channel, threadTs } = this.decodeThreadId(threadId);
     this.logger.debug("Slack: starting stream", { channel, threadTs });
+    const token = this.getToken();
     const streamer = this.client.chatStream({
       channel,
       thread_ts: threadTs,
       recipient_user_id: options.recipientUserId,
       recipient_team_id: options.recipientTeamId
     });
+    let first = true;
     for await (const chunk of textStream) {
-      await streamer.append({ markdown_text: chunk });
+      if (first) {
+        await streamer.append({ markdown_text: chunk, token });
+        first = false;
+      } else {
+        await streamer.append({ markdown_text: chunk });
+      }
     }
     const result = await streamer.stop();
     const messageTs = result.message?.ts ?? result.ts;
@@ -1220,7 +1528,9 @@ var SlackAdapter = class _SlackAdapter {
   async openDM(userId) {
     try {
       this.logger.debug("Slack API: conversations.open", { userId });
-      const result = await this.client.conversations.open({ users: userId });
+      const result = await this.client.conversations.open(
+        this.withToken({ users: userId })
+      );
       if (!result.channel?.id) {
         throw new NetworkError(
           "slack",
@@ -1277,12 +1587,14 @@ var SlackAdapter = class _SlackAdapter {
       limit,
       cursor
     });
-    const result = await this.client.conversations.replies({
-      channel,
-      ts: threadTs,
-      limit,
-      cursor
-    });
+    const result = await this.client.conversations.replies(
+      this.withToken({
+        channel,
+        ts: threadTs,
+        limit,
+        cursor
+      })
+    );
     const slackMessages = result.messages || [];
     const nextCursor = result.response_metadata?.next_cursor;
     this.logger.debug("Slack API: conversations.replies response", {
@@ -1318,14 +1630,16 @@ var SlackAdapter = class _SlackAdapter {
       latest
     });
     const fetchLimit = Math.min(1e3, Math.max(limit * 2, 200));
-    const result = await this.client.conversations.replies({
-      channel,
-      ts: threadTs,
-      limit: fetchLimit,
-      latest,
-      inclusive: false
-      // Don't include the cursor message itself
-    });
+    const result = await this.client.conversations.replies(
+      this.withToken({
+        channel,
+        ts: threadTs,
+        limit: fetchLimit,
+        latest,
+        inclusive: false
+        // Don't include the cursor message itself
+      })
+    );
     const slackMessages = result.messages || [];
     this.logger.debug("Slack API: conversations.replies response (backward)", {
       messageCount: slackMessages.length,
@@ -1353,7 +1667,9 @@ var SlackAdapter = class _SlackAdapter {
     const { channel, threadTs } = this.decodeThreadId(threadId);
     try {
       this.logger.debug("Slack API: conversations.info", { channel });
-      const result = await this.client.conversations.info({ channel });
+      const result = await this.client.conversations.info(
+        this.withToken({ channel })
+      );
       const channelInfo = result.channel;
       this.logger.debug("Slack API: conversations.info response", {
         channelName: channelInfo?.name,
@@ -1378,13 +1694,15 @@ var SlackAdapter = class _SlackAdapter {
   async fetchMessage(threadId, messageId) {
     const { channel, threadTs } = this.decodeThreadId(threadId);
     try {
-      const result = await this.client.conversations.replies({
-        channel,
-        ts: threadTs,
-        oldest: messageId,
-        inclusive: true,
-        limit: 1
-      });
+      const result = await this.client.conversations.replies(
+        this.withToken({
+          channel,
+          ts: threadTs,
+          oldest: messageId,
+          inclusive: true,
+          limit: 1
+        })
+      );
       const messages = result.messages || [];
       const target = messages.find((msg) => msg.ts === messageId);
       if (!target) return null;
@@ -1473,6 +1791,10 @@ var SlackAdapter = class _SlackAdapter {
    * - _botId is the bot ID (B_xxx) - matches event.bot_id
    */
   isMessageFromSelf(event) {
+    const ctx = this.requestContext.getStore();
+    if (ctx?.botUserId && event.user === ctx.botUserId) {
+      return true;
+    }
     if (this._botUserId && event.user === this._botUserId) {
       return true;
     }
@@ -1500,6 +1822,7 @@ export {
   SlackFormatConverter as SlackMarkdownConverter,
   cardToBlockKit,
   cardToFallbackText,
-  createSlackAdapter
+  createSlackAdapter,
+  decodeKey
 };
 //# sourceMappingURL=index.js.map