@aarekaz/switchboard-slack 0.3.1

package/dist/index.js

@@ -0,0 +1,779 @@
+// src/register.ts
+import { registry } from "@aarekaz/switchboard-core";
+
+// src/adapter.ts
+import bolt from "@slack/bolt";
+import { LRUCache } from "lru-cache";
+import {
+  ok,
+  err,
+  ConnectionError,
+  MessageSendError,
+  MessageEditError,
+  MessageDeleteError,
+  ReactionError
+} from "@aarekaz/switchboard-core";
+
+// src/normalizers.ts
+function normalizeMessage(slackMessage) {
+  const attachments = [];
+  if (slackMessage.files && Array.isArray(slackMessage.files)) {
+    for (const file of slackMessage.files) {
+      attachments.push({
+        id: file.id,
+        filename: file.name || "unknown",
+        url: file.url_private || file.permalink || "",
+        mimeType: file.mimetype || "application/octet-stream",
+        size: file.size || 0
+      });
+    }
+  }
+  return {
+    id: slackMessage.ts || slackMessage.message_ts || slackMessage.event_ts,
+    channelId: slackMessage.channel || slackMessage.channel_id || "",
+    userId: slackMessage.user || slackMessage.bot_id || "unknown",
+    text: extractPlainText(slackMessage),
+    timestamp: new Date(parseFloat(slackMessage.ts || slackMessage.event_ts || "0") * 1e3),
+    threadId: slackMessage.thread_ts,
+    attachments: attachments.length > 0 ? attachments : void 0,
+    platform: "slack",
+    _raw: slackMessage
+  };
+}
+function extractPlainText(message) {
+  if (message.blocks && Array.isArray(message.blocks)) {
+    const texts = [];
+    for (const block of message.blocks) {
+      if (block.type === "section" && block.text) {
+        texts.push(block.text.text || "");
+      } else if (block.type === "context" && block.elements) {
+        for (const element of block.elements) {
+          if (element.text) {
+            texts.push(element.text);
+          }
+        }
+      }
+    }
+    if (texts.length > 0) {
+      return texts.join("\\n");
+    }
+  }
+  return message.text || "";
+}
+function normalizeEmoji(slackEmoji) {
+  if (!/^:.+:$/.test(slackEmoji)) {
+    return slackEmoji;
+  }
+  return slackEmoji.replace(/^:|:$/g, "");
+}
+var EMOJI_MAP = {
+  "\u{1F44D}": "thumbsup",
+  "\u{1F44E}": "thumbsdown",
+  "\u2764\uFE0F": "heart",
+  "\u{1F602}": "joy",
+  "\u{1F60A}": "blush",
+  "\u{1F60D}": "heart_eyes",
+  "\u{1F389}": "tada",
+  "\u{1F525}": "fire",
+  "\u2705": "white_check_mark",
+  "\u274C": "x",
+  "\u2B50": "star",
+  "\u{1F4AF}": "100",
+  "\u{1F680}": "rocket",
+  "\u{1F440}": "eyes",
+  "\u{1F914}": "thinking_face",
+  "\u{1F62D}": "sob",
+  "\u{1F631}": "scream",
+  "\u{1F64F}": "pray",
+  "\u{1F4AA}": "muscle",
+  "\u{1F44F}": "clap",
+  "\u{1F3AF}": "dart",
+  "\u2728": "sparkles",
+  "\u{1F91D}": "handshake",
+  "\u{1F4A1}": "bulb",
+  "\u{1F41B}": "bug",
+  "\u26A1": "zap",
+  "\u{1F527}": "wrench",
+  "\u{1F4DD}": "memo",
+  "\u{1F3A8}": "art",
+  "\u267B\uFE0F": "recycle",
+  "\u{1F512}": "lock",
+  "\u{1F513}": "unlock",
+  "\u270F\uFE0F": "pencil2",
+  "\u{1F5D1}\uFE0F": "wastebasket"
+};
+function toSlackEmoji(emoji) {
+  if (/^:.+:$/.test(emoji)) {
+    return emoji.slice(1, -1);
+  }
+  if (EMOJI_MAP[emoji]) {
+    return EMOJI_MAP[emoji];
+  }
+  if (/^[a-z0-9_+-]+$/i.test(emoji)) {
+    return emoji;
+  }
+  const stripped = emoji.replace(/[\uFE00-\uFE0F]/g, "");
+  if (EMOJI_MAP[stripped]) {
+    return EMOJI_MAP[stripped];
+  }
+  return emoji;
+}
+function normalizeMessageEvent(event) {
+  return {
+    type: "message",
+    message: normalizeMessage(event)
+  };
+}
+function normalizeReactionEvent(event, action) {
+  return {
+    type: "reaction",
+    messageId: event.item.ts,
+    userId: event.user,
+    emoji: normalizeEmoji(event.reaction),
+    action
+  };
+}
+
+// src/adapter.ts
+var { App } = bolt;
+var SlackAdapter = class {
+  name = "slack-adapter";
+  platform = "slack";
+  app = null;
+  eventHandlers = /* @__PURE__ */ new Set();
+  config;
+  messageCache;
+  cacheHits = 0;
+  cacheMisses = 0;
+  constructor(config = {}) {
+    this.config = {
+      cacheSize: config.cacheSize || 1e3,
+      cacheTTL: config.cacheTTL || 1e3 * 60 * 60,
+      // 1 hour default
+      ...config
+    };
+    this.messageCache = new LRUCache({
+      max: this.config.cacheSize,
+      ttl: this.config.cacheTTL
+    });
+  }
+  /**
+   * Connect to Slack
+   */
+  async connect(credentials) {
+    const slackCreds = credentials;
+    if (!slackCreds.botToken) {
+      throw new ConnectionError(
+        "slack",
+        new Error("Slack bot token is required")
+      );
+    }
+    try {
+      const useSocketMode = !!(slackCreds.appToken || this.config.socketMode);
+      const appOptions = {
+        token: slackCreds.botToken
+      };
+      if (useSocketMode) {
+        if (!slackCreds.appToken) {
+          throw new ConnectionError(
+            "slack",
+            new Error("App token (appToken) is required for Socket Mode")
+          );
+        }
+        appOptions.socketMode = true;
+        appOptions.appToken = slackCreds.appToken;
+      } else if (slackCreds.signingSecret) {
+        appOptions.signingSecret = slackCreds.signingSecret;
+        if (this.config.port) {
+          appOptions.port = this.config.port;
+        }
+      } else {
+        throw new ConnectionError(
+          "slack",
+          new Error(
+            "Either appToken (for Socket Mode) or signingSecret (for Events API) is required"
+          )
+        );
+      }
+      this.app = new App(appOptions);
+      this.setupEventListeners();
+      await this.app.start();
+      if (process.env.NODE_ENV !== "production") {
+        console.log(
+          `\u2705 Slack adapter connected (${useSocketMode ? "Socket Mode" : "Events API"})`
+        );
+      }
+    } catch (error) {
+      throw new ConnectionError("slack", error);
+    }
+  }
+  /**
+   * Disconnect from Slack
+   */
+  async disconnect() {
+    if (this.app) {
+      await this.app.stop();
+      this.app = null;
+    }
+    this.messageCache.clear();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.app !== null;
+  }
+  /**
+   * Send a message to a channel
+   */
+  async sendMessage(channelId, text, options) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const slackOptions = options?.slack;
+      const result = await this.app.client.chat.postMessage({
+        channel: channelId,
+        text,
+        thread_ts: options?.threadId || slackOptions?.thread_ts,
+        blocks: slackOptions?.blocks,
+        unfurl_links: slackOptions?.unfurl_links,
+        unfurl_media: slackOptions?.unfurl_media,
+        metadata: slackOptions?.metadata
+      });
+      if (!result.ok || !result.message) {
+        return err(
+          new MessageSendError(
+            "slack",
+            channelId,
+            new Error(result.error || "Failed to send message")
+          )
+        );
+      }
+      const unifiedMessage = normalizeMessage(result.message);
+      if (!unifiedMessage.channelId) {
+        unifiedMessage.channelId = channelId;
+      }
+      this.cacheMessage(unifiedMessage);
+      return ok(unifiedMessage);
+    } catch (error) {
+      return err(
+        new MessageSendError(
+          "slack",
+          channelId,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Edit a message
+   */
+  async editMessage(messageRef, newText) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      let channelId;
+      if (typeof messageRef === "string") {
+        const context = this.messageCache.get(messageRef);
+        if (!context) {
+          this.cacheMisses++;
+          this.logCacheStats();
+          return err(
+            new MessageEditError(
+              "slack",
+              messageRef,
+              new Error(
+                'Cannot edit message: channel context not found.\\n\\nThis happens when:\\n1. The message is older than 1 hour (cache expired)\\n2. The bot restarted since the message was sent\\n3. The message was sent by another bot instance\\n\\nSolution: Pass the full message object instead:\\n  bot.editMessage(message, "text")  // \u2705 Works reliably\\n  bot.editMessage(message.id, "text")  // \u274C May fail on Slack'
+              )
+            )
+          );
+        }
+        this.cacheHits++;
+        this.logCacheStats();
+        channelId = context.channelId;
+      } else {
+        channelId = messageRef.channelId;
+      }
+      const result = await this.app.client.chat.update({
+        channel: channelId,
+        ts: messageId,
+        text: newText
+      });
+      if (!result.ok || !result.message) {
+        return err(
+          new MessageEditError(
+            "slack",
+            messageId,
+            new Error(result.error || "Failed to edit message")
+          )
+        );
+      }
+      return ok(normalizeMessage(result.message));
+    } catch (error) {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      return err(
+        new MessageEditError(
+          "slack",
+          messageId,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Delete a message
+   */
+  async deleteMessage(messageRef) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      let channelId;
+      if (typeof messageRef === "string") {
+        const context = this.messageCache.get(messageRef);
+        if (!context) {
+          this.cacheMisses++;
+          this.logCacheStats();
+          return err(
+            new MessageDeleteError(
+              "slack",
+              messageRef,
+              new Error(
+                "Cannot delete message: channel context not found.\\n\\nSolution: Pass the full message object instead:\\n  bot.deleteMessage(message)  // \u2705 Works reliably\\n  bot.deleteMessage(message.id)  // \u274C May fail on Slack"
+              )
+            )
+          );
+        }
+        this.cacheHits++;
+        this.logCacheStats();
+        channelId = context.channelId;
+      } else {
+        channelId = messageRef.channelId;
+      }
+      const result = await this.app.client.chat.delete({
+        channel: channelId,
+        ts: messageId
+      });
+      if (!result.ok) {
+        return err(
+          new MessageDeleteError(
+            "slack",
+            messageId,
+            new Error(result.error || "Failed to delete message")
+          )
+        );
+      }
+      this.messageCache.delete(messageId);
+      return ok(void 0);
+    } catch (error) {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      return err(
+        new MessageDeleteError(
+          "slack",
+          messageId,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Add a reaction to a message
+   */
+  async addReaction(messageRef, emoji) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      let channelId;
+      if (typeof messageRef === "string") {
+        const context = this.messageCache.get(messageRef);
+        if (!context) {
+          this.cacheMisses++;
+          this.logCacheStats();
+          return err(
+            new ReactionError(
+              "slack",
+              messageRef,
+              emoji,
+              new Error(
+                "Cannot add reaction: channel context not found.\\n\\nSolution: Pass the full message object instead:\\n  bot.addReaction(message, emoji)  // \u2705 Works reliably\\n  bot.addReaction(message.id, emoji)  // \u274C May fail on Slack"
+              )
+            )
+          );
+        }
+        this.cacheHits++;
+        this.logCacheStats();
+        channelId = context.channelId;
+      } else {
+        channelId = messageRef.channelId;
+      }
+      const slackEmoji = toSlackEmoji(emoji);
+      const result = await this.app.client.reactions.add({
+        channel: channelId,
+        timestamp: messageId,
+        name: slackEmoji.replace(/^:|:$/g, "")
+        // Slack API wants emoji without colons
+      });
+      if (!result.ok) {
+        return err(
+          new ReactionError(
+            "slack",
+            messageId,
+            emoji,
+            new Error(result.error || "Failed to add reaction")
+          )
+        );
+      }
+      return ok(void 0);
+    } catch (error) {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      return err(
+        new ReactionError(
+          "slack",
+          messageId,
+          emoji,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Remove a reaction from a message
+   */
+  async removeReaction(messageRef, emoji) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      let channelId;
+      if (typeof messageRef === "string") {
+        const context = this.messageCache.get(messageRef);
+        if (!context) {
+          this.cacheMisses++;
+          this.logCacheStats();
+          return err(
+            new ReactionError(
+              "slack",
+              messageRef,
+              emoji,
+              new Error(
+                "Cannot remove reaction: channel context not found.\\n\\nSolution: Pass the full message object instead:\\n  bot.removeReaction(message, emoji)  // \u2705 Works reliably\\n  bot.removeReaction(message.id, emoji)  // \u274C May fail on Slack"
+              )
+            )
+          );
+        }
+        this.cacheHits++;
+        this.logCacheStats();
+        channelId = context.channelId;
+      } else {
+        channelId = messageRef.channelId;
+      }
+      const slackEmoji = toSlackEmoji(emoji);
+      const result = await this.app.client.reactions.remove({
+        channel: channelId,
+        timestamp: messageId,
+        name: slackEmoji.replace(/^:|:$/g, "")
+        // Slack API wants emoji without colons
+      });
+      if (!result.ok) {
+        return err(
+          new ReactionError(
+            "slack",
+            messageId,
+            emoji,
+            new Error(result.error || "Failed to remove reaction")
+          )
+        );
+      }
+      return ok(void 0);
+    } catch (error) {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      return err(
+        new ReactionError(
+          "slack",
+          messageId,
+          emoji,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Create a thread (reply to a message)
+   */
+  async createThread(messageRef, text) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const messageId = typeof messageRef === "string" ? messageRef : messageRef.id;
+      let channelId;
+      if (typeof messageRef === "string") {
+        const context = this.messageCache.get(messageRef);
+        if (!context) {
+          this.cacheMisses++;
+          this.logCacheStats();
+          return err(
+            new MessageSendError(
+              "slack",
+              "unknown",
+              new Error(
+                "Cannot create thread: channel context not found.\\n\\nSolution: Pass the full message object instead:\\n  bot.createThread(message, text)  // \u2705 Works reliably\\n  bot.createThread(message.id, text)  // \u274C May fail on Slack"
+              )
+            )
+          );
+        }
+        this.cacheHits++;
+        this.logCacheStats();
+        channelId = context.channelId;
+      } else {
+        channelId = messageRef.channelId;
+      }
+      const result = await this.app.client.chat.postMessage({
+        channel: channelId,
+        text,
+        thread_ts: messageId
+        // This creates/replies in a thread
+      });
+      if (!result.ok || !result.message) {
+        return err(
+          new MessageSendError(
+            "slack",
+            channelId,
+            new Error(result.error || "Failed to create thread")
+          )
+        );
+      }
+      const unifiedMessage = normalizeMessage(result.message);
+      this.cacheMessage(unifiedMessage);
+      return ok(unifiedMessage);
+    } catch (error) {
+      const channelId = typeof messageRef === "string" ? "unknown" : messageRef.channelId;
+      return err(
+        new MessageSendError(
+          "slack",
+          channelId,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Upload a file to a channel
+   */
+  async uploadFile(channelId, file, options) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      return err(
+        new MessageSendError(
+          "slack",
+          channelId,
+          new Error("File upload not yet implemented for Slack adapter")
+        )
+      );
+    } catch (error) {
+      return err(
+        new MessageSendError(
+          "slack",
+          channelId,
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+    }
+  }
+  /**
+   * Subscribe to platform events
+   */
+  onEvent(handler) {
+    this.eventHandlers.add(handler);
+  }
+  /**
+   * Get list of channels
+   */
+  async getChannels() {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      const result = await this.app.client.conversations.list({
+        types: "public_channel,private_channel"
+      });
+      if (!result.ok || !result.channels) {
+        return err(
+          new Error(result.error || "Failed to fetch channels")
+        );
+      }
+      const channels = result.channels.map((channel) => ({
+        id: channel.id,
+        name: channel.name || "unknown",
+        type: "text",
+        isPrivate: channel.is_private || false,
+        topic: channel.topic?.value
+      }));
+      return ok(channels);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Get list of users
+   */
+  async getUsers(channelId) {
+    if (!this.app) {
+      return err(new ConnectionError("slack", new Error("Not connected")));
+    }
+    try {
+      if (channelId) {
+        const result = await this.app.client.conversations.members({
+          channel: channelId
+        });
+        if (!result.ok || !result.members) {
+          return err(
+            new Error(result.error || "Failed to fetch channel members")
+          );
+        }
+        const users = [];
+        for (const userId of result.members) {
+          const userInfo = await this.app.client.users.info({ user: userId });
+          if (userInfo.ok && userInfo.user) {
+            users.push({
+              id: userInfo.user.id,
+              username: userInfo.user.name || "unknown",
+              displayName: userInfo.user.real_name || userInfo.user.profile?.display_name,
+              isBot: userInfo.user.is_bot || false,
+              avatarUrl: userInfo.user.profile?.image_512
+            });
+          }
+        }
+        return ok(users);
+      } else {
+        const result = await this.app.client.users.list();
+        if (!result.ok || !result.members) {
+          return err(
+            new Error(result.error || "Failed to fetch users")
+          );
+        }
+        const users = result.members.map((user) => ({
+          id: user.id,
+          username: user.name || "unknown",
+          displayName: user.real_name || user.profile?.display_name,
+          isBot: user.is_bot || false,
+          avatarUrl: user.profile?.image_512
+        }));
+        return ok(users);
+      }
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Normalize platform message to UnifiedMessage
+   */
+  normalizeMessage(platformMessage) {
+    return normalizeMessage(platformMessage);
+  }
+  /**
+   * Normalize platform event to UnifiedEvent
+   */
+  normalizeEvent(platformEvent) {
+    const event = platformEvent;
+    if (event.type === "message" || event.message) {
+      return normalizeMessageEvent(event);
+    }
+    if (event.type === "reaction_added") {
+      return normalizeReactionEvent(event, "added");
+    }
+    if (event.type === "reaction_removed") {
+      return normalizeReactionEvent(event, "removed");
+    }
+    return null;
+  }
+  /**
+   * Set up event listeners for Slack
+   */
+  setupEventListeners() {
+    if (!this.app) return;
+    this.app.message(async ({ message }) => {
+      if ("subtype" in message && message.subtype !== void 0) {
+        return;
+      }
+      const unifiedMessage = normalizeMessage(message);
+      this.cacheMessage(unifiedMessage);
+      const event = {
+        type: "message",
+        message: unifiedMessage
+      };
+      this.eventHandlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error("[Switchboard] Error in message handler:", error);
+        }
+      });
+    });
+    this.app.event("reaction_added", async ({ event }) => {
+      const reactionEvent = normalizeReactionEvent(event, "added");
+      this.eventHandlers.forEach((handler) => {
+        try {
+          handler(reactionEvent);
+        } catch (error) {
+          console.error("[Switchboard] Error in reaction handler:", error);
+        }
+      });
+    });
+    this.app.event("reaction_removed", async ({ event }) => {
+      const reactionEvent = normalizeReactionEvent(event, "removed");
+      this.eventHandlers.forEach((handler) => {
+        try {
+          handler(reactionEvent);
+        } catch (error) {
+          console.error("[Switchboard] Error in reaction handler:", error);
+        }
+      });
+    });
+  }
+  /**
+   * Cache a message's context
+   */
+  cacheMessage(message) {
+    this.messageCache.set(message.id, {
+      channelId: message.channelId,
+      threadId: message.threadId,
+      timestamp: message.timestamp
+    });
+  }
+  /**
+   * Log cache statistics (every 1000 operations)
+   */
+  logCacheStats() {
+    const total = this.cacheHits + this.cacheMisses;
+    if (total > 0 && total % 1e3 === 0) {
+      const hitRate = (this.cacheHits / total * 100).toFixed(1);
+      console.log(`[Switchboard] Slack cache hit rate: ${hitRate}% (${this.cacheHits}/${total})`);
+    }
+  }
+};
+
+// src/register.ts
+var slackAdapter = new SlackAdapter();
+registry.register("slack", slackAdapter);
+if (process.env.NODE_ENV !== "production") {
+  console.log("[Switchboard] Slack adapter registered");
+}
+export {
+  SlackAdapter,
+  normalizeEmoji,
+  normalizeMessage,
+  normalizeMessageEvent,
+  normalizeReactionEvent,
+  toSlackEmoji
+};
+//# sourceMappingURL=index.js.map