@pocketping/sdk-node 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -20,8 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DiscordBridge: () => DiscordBridge,
   MemoryStorage: () => MemoryStorage,
-  PocketPing: () => PocketPing
+  PocketPing: () => PocketPing,
+  SlackBridge: () => SlackBridge,
+  TelegramBridge: () => TelegramBridge,
+  WebhookHandler: () => WebhookHandler
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -35,6 +39,7 @@ var MemoryStorage = class {
     this.sessions = /* @__PURE__ */ new Map();
     this.messages = /* @__PURE__ */ new Map();
     this.messageById = /* @__PURE__ */ new Map();
+    this.bridgeMessageIds = /* @__PURE__ */ new Map();
   }
   async createSession(session) {
     this.sessions.set(session.id, session);
@@ -79,6 +84,23 @@ var MemoryStorage = class {
   async getMessage(messageId) {
     return this.messageById.get(messageId) ?? null;
   }
+  async updateMessage(message) {
+    this.messageById.set(message.id, message);
+    const sessionMessages = this.messages.get(message.sessionId);
+    if (sessionMessages) {
+      const index = sessionMessages.findIndex((m) => m.id === message.id);
+      if (index !== -1) {
+        sessionMessages[index] = message;
+      }
+    }
+  }
+  async saveBridgeMessageIds(messageId, bridgeIds) {
+    const existing = this.bridgeMessageIds.get(messageId) ?? {};
+    this.bridgeMessageIds.set(messageId, { ...existing, ...bridgeIds });
+  }
+  async getBridgeMessageIds(messageId) {
+    return this.bridgeMessageIds.get(messageId) ?? null;
+  }
   async cleanupOldSessions(olderThan) {
     let count = 0;
     for (const [id, session] of this.sessions) {
@@ -332,6 +354,12 @@ var PocketPing = class {
           case "identify":
             result = await this.handleIdentify(body);
             break;
+          case "edit":
+            result = await this.handleEditMessage(body);
+            break;
+          case "delete":
+            result = await this.handleDeleteMessage(body);
+            break;
           default:
             if (next) {
               next();
@@ -656,6 +684,99 @@ var PocketPing = class {
     return this.storage.getSession(sessionId);
   }
   // ─────────────────────────────────────────────────────────────────
+  // Message Edit/Delete
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Handle message edit from widget
+   * Only the message sender can edit their own messages
+   */
+  async handleEditMessage(request) {
+    const session = await this.storage.getSession(request.sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const message = await this.storage.getMessage(request.messageId);
+    if (!message) {
+      throw new Error("Message not found");
+    }
+    if (message.sessionId !== request.sessionId) {
+      throw new Error("Message does not belong to this session");
+    }
+    if (message.deletedAt) {
+      throw new Error("Cannot edit deleted message");
+    }
+    if (message.sender !== "visitor") {
+      throw new Error("Cannot edit this message");
+    }
+    if (!request.content || request.content.trim().length === 0) {
+      throw new Error("Content is required");
+    }
+    if (request.content.length > 4e3) {
+      throw new Error("Content exceeds maximum length");
+    }
+    message.content = request.content.trim();
+    message.editedAt = /* @__PURE__ */ new Date();
+    if (this.storage.updateMessage) {
+      await this.storage.updateMessage(message);
+    } else {
+      await this.storage.saveMessage(message);
+    }
+    await this.syncEditToBridges(message.id, message.content);
+    this.broadcastToSession(request.sessionId, {
+      type: "message_edited",
+      data: {
+        messageId: message.id,
+        content: message.content,
+        editedAt: message.editedAt.toISOString()
+      }
+    });
+    return {
+      message: {
+        id: message.id,
+        content: message.content,
+        editedAt: message.editedAt.toISOString()
+      }
+    };
+  }
+  /**
+   * Handle message delete from widget
+   * Only the message sender can delete their own messages
+   */
+  async handleDeleteMessage(request) {
+    const session = await this.storage.getSession(request.sessionId);
+    if (!session) {
+      throw new Error("Session not found");
+    }
+    const message = await this.storage.getMessage(request.messageId);
+    if (!message) {
+      throw new Error("Message not found");
+    }
+    if (message.sessionId !== request.sessionId) {
+      throw new Error("Message does not belong to this session");
+    }
+    if (message.deletedAt) {
+      throw new Error("Message already deleted");
+    }
+    if (message.sender !== "visitor") {
+      throw new Error("Cannot delete this message");
+    }
+    await this.syncDeleteToBridges(message.id);
+    message.deletedAt = /* @__PURE__ */ new Date();
+    if (this.storage.updateMessage) {
+      await this.storage.updateMessage(message);
+    } else {
+      await this.storage.saveMessage(message);
+    }
+    this.broadcastToSession(request.sessionId, {
+      type: "message_deleted",
+      data: {
+        messageId: message.id,
+        deletedAt: message.deletedAt.toISOString()
+      }
+    });
+    return { deleted: true };
+  }
+  // ─────────────────────────────────────────────────────────────────
   // Operator Actions (for bridges)
   // ─────────────────────────────────────────────────────────────────
   async sendOperatorMessage(sessionId, content) {
@@ -799,9 +920,23 @@ var PocketPing = class {
           case "new_session":
             await bridge.onNewSession?.(args[0]);
             break;
-          case "message":
-            await bridge.onVisitorMessage?.(args[0], args[1]);
+          case "message": {
+            const message = args[0];
+            const session = args[1];
+            const result = await bridge.onVisitorMessage?.(message, session);
+            if (result?.messageId && this.storage.saveBridgeMessageIds) {
+              const bridgeIds = {};
+              if (bridge.name === "telegram") {
+                bridgeIds.telegramMessageId = result.messageId;
+              } else if (bridge.name === "discord") {
+                bridgeIds.discordMessageId = result.messageId;
+              } else if (bridge.name === "slack") {
+                bridgeIds.slackMessageTs = result.messageId;
+              }
+              await this.storage.saveBridgeMessageIds(message.id, bridgeIds);
+            }
             break;
+          }
         }
       } catch (err) {
         console.error(`[PocketPing] Bridge ${bridge.name} error:`, err);
@@ -835,6 +970,66 @@ var PocketPing = class {
       }
     }
   }
+  /**
+   * Sync message edit to all bridges that support it
+   */
+  async syncEditToBridges(messageId, newContent) {
+    if (!this.storage.getBridgeMessageIds) {
+      return;
+    }
+    const bridgeIds = await this.storage.getBridgeMessageIds(messageId);
+    if (!bridgeIds) {
+      return;
+    }
+    for (const bridge of this.bridges) {
+      if (!bridge.onMessageEdit) continue;
+      try {
+        let bridgeMessageId;
+        if (bridge.name === "telegram" && bridgeIds.telegramMessageId) {
+          bridgeMessageId = bridgeIds.telegramMessageId;
+        } else if (bridge.name === "discord" && bridgeIds.discordMessageId) {
+          bridgeMessageId = bridgeIds.discordMessageId;
+        } else if (bridge.name === "slack" && bridgeIds.slackMessageTs) {
+          bridgeMessageId = bridgeIds.slackMessageTs;
+        }
+        if (bridgeMessageId) {
+          await bridge.onMessageEdit(messageId, newContent, bridgeMessageId);
+        }
+      } catch (err) {
+        console.error(`[PocketPing] Bridge ${bridge.name} edit sync error:`, err);
+      }
+    }
+  }
+  /**
+   * Sync message delete to all bridges that support it
+   */
+  async syncDeleteToBridges(messageId) {
+    if (!this.storage.getBridgeMessageIds) {
+      return;
+    }
+    const bridgeIds = await this.storage.getBridgeMessageIds(messageId);
+    if (!bridgeIds) {
+      return;
+    }
+    for (const bridge of this.bridges) {
+      if (!bridge.onMessageDelete) continue;
+      try {
+        let bridgeMessageId;
+        if (bridge.name === "telegram" && bridgeIds.telegramMessageId) {
+          bridgeMessageId = bridgeIds.telegramMessageId;
+        } else if (bridge.name === "discord" && bridgeIds.discordMessageId) {
+          bridgeMessageId = bridgeIds.discordMessageId;
+        } else if (bridge.name === "slack" && bridgeIds.slackMessageTs) {
+          bridgeMessageId = bridgeIds.slackMessageTs;
+        }
+        if (bridgeMessageId) {
+          await bridge.onMessageDelete(messageId, bridgeMessageId);
+        }
+      } catch (err) {
+        console.error(`[PocketPing] Bridge ${bridge.name} delete sync error:`, err);
+      }
+    }
+  }
   // ─────────────────────────────────────────────────────────────────
   // Webhook Forwarding
   // ─────────────────────────────────────────────────────────────────
@@ -994,8 +1189,1381 @@ var PocketPing = class {
     });
   }
 };
+
+// src/webhooks.ts
+var DISCORD_INTERACTION_PING = 1;
+var DISCORD_INTERACTION_APPLICATION_COMMAND = 2;
+var DISCORD_RESPONSE_PONG = 1;
+var DISCORD_RESPONSE_CHANNEL_MESSAGE = 4;
+var WebhookHandler = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create an Express/Connect middleware for handling Telegram webhooks
+   */
+  handleTelegramWebhook() {
+    return async (req, res) => {
+      if (!this.config.telegramBotToken) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: "Telegram not configured" }));
+        return;
+      }
+      try {
+        const body = await this.parseBody(req);
+        const update = body;
+        if (update.edited_message) {
+          const msg = update.edited_message;
+          if (msg.text?.startsWith("/")) {
+            this.writeOK(res);
+            return;
+          }
+          const text = msg.text ?? msg.caption ?? "";
+          if (!text) {
+            this.writeOK(res);
+            return;
+          }
+          const topicId = msg.message_thread_id;
+          if (!topicId) {
+            this.writeOK(res);
+            return;
+          }
+          if (this.config.onOperatorMessageEdit) {
+            const editedAt = msg.edit_date ? new Date(msg.edit_date * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+            await this.config.onOperatorMessageEdit(
+              String(topicId),
+              msg.message_id,
+              text,
+              "telegram",
+              editedAt
+            );
+          }
+          this.writeOK(res);
+          return;
+        }
+        if (update.message) {
+          const msg = update.message;
+          if (msg.text?.startsWith("/")) {
+            this.writeOK(res);
+            return;
+          }
+          const text = msg.text ?? msg.caption ?? "";
+          let media = null;
+          if (msg.photo && msg.photo.length > 0) {
+            const largest = msg.photo[msg.photo.length - 1];
+            media = {
+              fileId: largest.file_id,
+              filename: `photo_${Date.now()}.jpg`,
+              mimeType: "image/jpeg",
+              size: largest.file_size ?? 0
+            };
+          } else if (msg.document) {
+            media = {
+              fileId: msg.document.file_id,
+              filename: msg.document.file_name ?? `document_${Date.now()}`,
+              mimeType: msg.document.mime_type ?? "application/octet-stream",
+              size: msg.document.file_size ?? 0
+            };
+          } else if (msg.audio) {
+            media = {
+              fileId: msg.audio.file_id,
+              filename: msg.audio.file_name ?? `audio_${Date.now()}.mp3`,
+              mimeType: msg.audio.mime_type ?? "audio/mpeg",
+              size: msg.audio.file_size ?? 0
+            };
+          } else if (msg.video) {
+            media = {
+              fileId: msg.video.file_id,
+              filename: msg.video.file_name ?? `video_${Date.now()}.mp4`,
+              mimeType: msg.video.mime_type ?? "video/mp4",
+              size: msg.video.file_size ?? 0
+            };
+          } else if (msg.voice) {
+            media = {
+              fileId: msg.voice.file_id,
+              filename: `voice_${Date.now()}.ogg`,
+              mimeType: msg.voice.mime_type ?? "audio/ogg",
+              size: msg.voice.file_size ?? 0
+            };
+          }
+          if (!text && !media) {
+            this.writeOK(res);
+            return;
+          }
+          const topicId = msg.message_thread_id;
+          if (!topicId) {
+            this.writeOK(res);
+            return;
+          }
+          const operatorName = msg.from?.first_name ?? "Operator";
+          const replyToBridgeMessageId = msg.reply_to_message?.message_id ?? null;
+          const attachments = [];
+          if (media) {
+            const data = await this.downloadTelegramFile(media.fileId);
+            if (data) {
+              attachments.push({
+                filename: media.filename,
+                mimeType: media.mimeType,
+                size: media.size,
+                data,
+                bridgeFileId: media.fileId
+              });
+            }
+          }
+          await this.config.onOperatorMessage(
+            String(topicId),
+            text,
+            operatorName,
+            "telegram",
+            attachments,
+            replyToBridgeMessageId,
+            msg.message_id
+          );
+        }
+        this.writeOK(res);
+      } catch (error) {
+        console.error("[WebhookHandler] Telegram error:", error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    };
+  }
+  /**
+   * Create an Express/Connect middleware for handling Slack webhooks
+   */
+  handleSlackWebhook() {
+    return async (req, res) => {
+      if (!this.config.slackBotToken) {
+        res.statusCode = 404;
+        res.end(JSON.stringify({ error: "Slack not configured" }));
+        return;
+      }
+      try {
+        const body = await this.parseBody(req);
+        const payload = body;
+        if (payload.type === "url_verification" && payload.challenge) {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ challenge: payload.challenge }));
+          return;
+        }
+        if (payload.type === "event_callback" && payload.event) {
+          const event = payload.event;
+          const isAllowedBot = (botId) => !!botId && (this.config.allowedBotIds?.includes(botId) ?? false);
+          if (event.subtype === "message_changed") {
+            if (!this.config.onOperatorMessageEdit) {
+              this.writeOK(res);
+              return;
+            }
+            const botId = event.message?.bot_id ?? event.previous_message?.bot_id ?? event.bot_id;
+            if (botId && !isAllowedBot(botId)) {
+              this.writeOK(res);
+              return;
+            }
+            const threadTs = event.message?.thread_ts ?? event.previous_message?.thread_ts;
+            const messageTs = event.message?.ts ?? event.previous_message?.ts;
+            const text = event.message?.text ?? "";
+            if (threadTs && messageTs) {
+              await this.config.onOperatorMessageEdit(
+                threadTs,
+                messageTs,
+                text,
+                "slack",
+                (/* @__PURE__ */ new Date()).toISOString()
+              );
+            }
+            this.writeOK(res);
+            return;
+          }
+          if (event.subtype === "message_deleted") {
+            if (!this.config.onOperatorMessageDelete) {
+              this.writeOK(res);
+              return;
+            }
+            const botId = event.previous_message?.bot_id ?? event.bot_id;
+            if (botId && !isAllowedBot(botId)) {
+              this.writeOK(res);
+              return;
+            }
+            const threadTs = event.previous_message?.thread_ts;
+            const messageTs = event.deleted_ts ?? event.previous_message?.ts;
+            if (threadTs && messageTs) {
+              await this.config.onOperatorMessageDelete(
+                threadTs,
+                messageTs,
+                "slack",
+                (/* @__PURE__ */ new Date()).toISOString()
+              );
+            }
+            this.writeOK(res);
+            return;
+          }
+          const hasContent = event.type === "message" && event.thread_ts && (!event.bot_id || isAllowedBot(event.bot_id)) && !event.subtype;
+          const hasFiles = event.files && event.files.length > 0;
+          if (hasContent && (event.text || hasFiles)) {
+            const threadTs = event.thread_ts;
+            const text = event.text ?? "";
+            const attachments = [];
+            if (hasFiles && event.files) {
+              for (const file of event.files) {
+                const data = await this.downloadSlackFile(file);
+                if (data) {
+                  attachments.push({
+                    filename: file.name,
+                    mimeType: file.mimetype,
+                    size: file.size,
+                    data,
+                    bridgeFileId: file.id
+                  });
+                }
+              }
+            }
+            let operatorName = "Operator";
+            if (event.user) {
+              const name = await this.getSlackUserName(event.user);
+              if (name) operatorName = name;
+            }
+            await this.config.onOperatorMessage(
+              threadTs,
+              text,
+              operatorName,
+              "slack",
+              attachments,
+              null,
+              event.ts ?? null
+            );
+          }
+        }
+        this.writeOK(res);
+      } catch (error) {
+        console.error("[WebhookHandler] Slack error:", error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    };
+  }
+  /**
+   * Create an Express/Connect middleware for handling Discord webhooks
+   */
+  handleDiscordWebhook() {
+    return async (req, res) => {
+      try {
+        const body = await this.parseBody(req);
+        const interaction = body;
+        if (interaction.type === DISCORD_INTERACTION_PING) {
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ type: DISCORD_RESPONSE_PONG }));
+          return;
+        }
+        if (interaction.type === DISCORD_INTERACTION_APPLICATION_COMMAND && interaction.data) {
+          if (interaction.data.name === "reply") {
+            const threadId = interaction.channel_id;
+            const content = interaction.data.options?.find(
+              (opt) => opt.name === "message"
+            )?.value;
+            if (threadId && content) {
+              const operatorName = interaction.member?.user?.username ?? interaction.user?.username ?? "Operator";
+              await this.config.onOperatorMessage(
+                threadId,
+                content,
+                operatorName,
+                "discord",
+                [],
+                null
+              );
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  type: DISCORD_RESPONSE_CHANNEL_MESSAGE,
+                  data: { content: "\u2705 Message sent to visitor" }
+                })
+              );
+              return;
+            }
+          }
+        }
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ type: DISCORD_RESPONSE_PONG }));
+      } catch (error) {
+        console.error("[WebhookHandler] Discord error:", error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Helper Methods
+  // ─────────────────────────────────────────────────────────────────
+  async parseBody(req) {
+    if (req.body) return req.body;
+    return new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => data += chunk);
+      req.on("end", () => {
+        try {
+          resolve(data ? JSON.parse(data) : {});
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  writeOK(res) {
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true }));
+  }
+  async downloadTelegramFile(fileId) {
+    try {
+      const botToken = this.config.telegramBotToken;
+      const getFileUrl = `https://api.telegram.org/bot${botToken}/getFile?file_id=${fileId}`;
+      const getFileResp = await fetch(getFileUrl);
+      const getFileResult = await getFileResp.json();
+      if (!getFileResult.ok || !getFileResult.result?.file_path) {
+        return null;
+      }
+      const downloadUrl = `https://api.telegram.org/file/bot${botToken}/${getFileResult.result.file_path}`;
+      const downloadResp = await fetch(downloadUrl);
+      const arrayBuffer = await downloadResp.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      console.error("[WebhookHandler] Telegram file download error:", error);
+      return null;
+    }
+  }
+  async downloadSlackFile(file) {
+    try {
+      const downloadUrl = file.url_private_download ?? file.url_private;
+      const resp = await fetch(downloadUrl, {
+        headers: {
+          Authorization: `Bearer ${this.config.slackBotToken}`
+        }
+      });
+      if (!resp.ok) {
+        return null;
+      }
+      const arrayBuffer = await resp.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      console.error("[WebhookHandler] Slack file download error:", error);
+      return null;
+    }
+  }
+  async getSlackUserName(userId) {
+    try {
+      const url = `https://slack.com/api/users.info?user=${userId}`;
+      const resp = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${this.config.slackBotToken}`
+        }
+      });
+      const result = await resp.json();
+      if (!result.ok) {
+        return null;
+      }
+      return result.user?.real_name ?? result.user?.name ?? null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/bridges/telegram.ts
+var TelegramBridge = class {
+  constructor(botToken, chatId, options = {}) {
+    this.name = "telegram";
+    this.botToken = botToken;
+    this.chatId = chatId;
+    this.parseMode = options.parseMode ?? "HTML";
+    this.disableNotification = options.disableNotification ?? false;
+    this.baseUrl = `https://api.telegram.org/bot${botToken}`;
+  }
+  /**
+   * Initialize the bridge (optional setup)
+   */
+  async init(pocketping) {
+    this.pocketping = pocketping;
+    try {
+      const response = await fetch(`${this.baseUrl}/getMe`);
+      const data = await response.json();
+      if (!data.ok) {
+        console.error("[TelegramBridge] Invalid bot token:", data.description);
+      }
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to verify bot token:", error);
+    }
+  }
+  /**
+   * Called when a new chat session is created
+   */
+  async onNewSession(session) {
+    const url = session.metadata?.url || "Unknown page";
+    const text = this.formatNewSession(session.visitorId, url);
+    try {
+      await this.sendMessage(text);
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send new session notification:", error);
+    }
+  }
+  /**
+   * Called when a visitor sends a message.
+   * Returns the Telegram message ID for edit/delete sync.
+   */
+  async onVisitorMessage(message, session) {
+    const text = this.formatVisitorMessage(session.visitorId, message.content);
+    let replyToMessageId;
+    if (message.replyTo) {
+      const storage = this.pocketping?.getStorage();
+      if (storage?.getBridgeMessageIds) {
+        const ids = await storage.getBridgeMessageIds(message.replyTo);
+        if (ids?.telegramMessageId) {
+          replyToMessageId = ids.telegramMessageId;
+        }
+      }
+    }
+    try {
+      const messageId = await this.sendMessage(text, replyToMessageId);
+      return { messageId };
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send visitor message:", error);
+      return {};
+    }
+  }
+  /**
+   * Called when an operator sends a message (for cross-bridge sync)
+   */
+  async onOperatorMessage(message, _session, sourceBridge, operatorName) {
+    if (sourceBridge === "telegram") {
+      return;
+    }
+    const name = operatorName || "Operator";
+    const text = this.parseMode === "HTML" ? `<b>${this.escapeHtml(name)}:</b>
+${this.escapeHtml(message.content)}` : `*${this.escapeMarkdown(name)}:*
+${this.escapeMarkdown(message.content)}`;
+    try {
+      await this.sendMessage(text);
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send operator message:", error);
+    }
+  }
+  /**
+   * Called when visitor starts/stops typing
+   */
+  async onTyping(sessionId, isTyping) {
+    if (!isTyping) return;
+    try {
+      await this.sendChatAction("typing");
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send typing action:", error);
+    }
+  }
+  /**
+   * Called when a visitor edits their message.
+   * @returns true if edit succeeded, false otherwise
+   */
+  async onMessageEdit(_messageId, newContent, bridgeMessageId) {
+    try {
+      const response = await fetch(`${this.baseUrl}/editMessageText`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          message_id: bridgeMessageId,
+          text: `${newContent}
+
+<i>(edited)</i>`,
+          parse_mode: this.parseMode
+        })
+      });
+      const data = await response.json();
+      if (!data.ok) {
+        console.error("[TelegramBridge] Edit failed:", data.description);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to edit message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a visitor deletes their message.
+   * @returns true if delete succeeded, false otherwise
+   */
+  async onMessageDelete(_messageId, bridgeMessageId) {
+    try {
+      const response = await fetch(`${this.baseUrl}/deleteMessage`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          chat_id: this.chatId,
+          message_id: bridgeMessageId
+        })
+      });
+      const data = await response.json();
+      if (!data.ok) {
+        console.error("[TelegramBridge] Delete failed:", data.description);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to delete message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a custom event is triggered from the widget
+   */
+  async onCustomEvent(event, session) {
+    const dataStr = event.data ? JSON.stringify(event.data, null, 2) : "";
+    const text = this.parseMode === "HTML" ? `<b>Custom Event:</b> ${this.escapeHtml(event.name)}
+<b>Visitor:</b> ${this.escapeHtml(session.visitorId)}${dataStr ? `
+<pre>${this.escapeHtml(dataStr)}</pre>` : ""}` : `*Custom Event:* ${this.escapeMarkdown(event.name)}
+*Visitor:* ${this.escapeMarkdown(session.visitorId)}${dataStr ? `
+\`\`\`
+${dataStr}
+\`\`\`` : ""}`;
+    try {
+      await this.sendMessage(text);
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send custom event:", error);
+    }
+  }
+  /**
+   * Called when a user identifies themselves via PocketPing.identify()
+   */
+  async onIdentityUpdate(session) {
+    if (!session.identity) return;
+    const identity = session.identity;
+    let text;
+    if (this.parseMode === "HTML") {
+      text = `<b>User Identified</b>
+<b>ID:</b> ${this.escapeHtml(identity.id)}
+` + (identity.name ? `<b>Name:</b> ${this.escapeHtml(identity.name)}
+` : "") + (identity.email ? `<b>Email:</b> ${this.escapeHtml(identity.email)}` : "");
+    } else {
+      text = `*User Identified*
+*ID:* ${this.escapeMarkdown(identity.id)}
+` + (identity.name ? `*Name:* ${this.escapeMarkdown(identity.name)}
+` : "") + (identity.email ? `*Email:* ${this.escapeMarkdown(identity.email)}` : "");
+    }
+    try {
+      await this.sendMessage(text.trim());
+    } catch (error) {
+      console.error("[TelegramBridge] Failed to send identity update:", error);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Private helper methods
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Send a message to the Telegram chat
+   */
+  async sendMessage(text, replyToMessageId) {
+    const response = await fetch(`${this.baseUrl}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: this.chatId,
+        text,
+        parse_mode: this.parseMode,
+        disable_notification: this.disableNotification,
+        ...replyToMessageId ? { reply_to_message_id: replyToMessageId } : {}
+      })
+    });
+    const data = await response.json();
+    if (!data.ok) {
+      throw new Error(`Telegram API error: ${data.description}`);
+    }
+    return data.result?.message_id;
+  }
+  /**
+   * Send a chat action (e.g., "typing")
+   */
+  async sendChatAction(action) {
+    await fetch(`${this.baseUrl}/sendChatAction`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chat_id: this.chatId,
+        action
+      })
+    });
+  }
+  /**
+   * Format new session notification
+   */
+  formatNewSession(visitorId, url) {
+    if (this.parseMode === "HTML") {
+      return `<b>New chat session</b>
+<b>Visitor:</b> ${this.escapeHtml(visitorId)}
+<b>Page:</b> ${this.escapeHtml(url)}`;
+    }
+    return `*New chat session*
+*Visitor:* ${this.escapeMarkdown(visitorId)}
+*Page:* ${this.escapeMarkdown(url)}`;
+  }
+  /**
+   * Format visitor message
+   */
+  formatVisitorMessage(visitorId, content) {
+    if (this.parseMode === "HTML") {
+      return `<b>${this.escapeHtml(visitorId)}:</b>
+${this.escapeHtml(content)}`;
+    }
+    return `*${this.escapeMarkdown(visitorId)}:*
+${this.escapeMarkdown(content)}`;
+  }
+  /**
+   * Escape HTML special characters
+   */
+  escapeHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  /**
+   * Escape Markdown special characters
+   */
+  escapeMarkdown(text) {
+    return text.replace(/[_*[\]()~`>#+=|{}.!-]/g, "\\$&");
+  }
+};
+
+// src/bridges/discord.ts
+var DiscordBridge = class _DiscordBridge {
+  constructor(config) {
+    this.name = "discord";
+    this.mode = config.mode;
+    this.webhookUrl = config.webhookUrl;
+    this.botToken = config.botToken;
+    this.channelId = config.channelId;
+    this.username = config.username;
+    this.avatarUrl = config.avatarUrl;
+  }
+  /**
+   * Create a Discord bridge using a webhook URL
+   */
+  static webhook(webhookUrl, options = {}) {
+    return new _DiscordBridge({
+      mode: "webhook",
+      webhookUrl,
+      username: options.username,
+      avatarUrl: options.avatarUrl
+    });
+  }
+  /**
+   * Create a Discord bridge using a bot token
+   */
+  static bot(botToken, channelId, options = {}) {
+    return new _DiscordBridge({
+      mode: "bot",
+      botToken,
+      channelId,
+      username: options.username,
+      avatarUrl: options.avatarUrl
+    });
+  }
+  /**
+   * Initialize the bridge (optional setup)
+   */
+  async init(pocketping) {
+    this.pocketping = pocketping;
+    if (this.mode === "bot" && this.botToken) {
+      try {
+        const response = await fetch("https://discord.com/api/v10/users/@me", {
+          headers: { Authorization: `Bot ${this.botToken}` }
+        });
+        if (!response.ok) {
+          console.error("[DiscordBridge] Invalid bot token");
+        }
+      } catch (error) {
+        console.error("[DiscordBridge] Failed to verify bot token:", error);
+      }
+    }
+  }
+  /**
+   * Called when a new chat session is created
+   */
+  async onNewSession(session) {
+    const url = session.metadata?.url || "Unknown page";
+    const embed = {
+      title: "New chat session",
+      color: 5793266,
+      // Discord blurple
+      fields: [
+        { name: "Visitor", value: session.visitorId, inline: true },
+        { name: "Page", value: url, inline: false }
+      ],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await this.sendEmbed(embed);
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send new session notification:", error);
+    }
+  }
+  /**
+   * Called when a visitor sends a message.
+   * Returns the Discord message ID for edit/delete sync.
+   */
+  async onVisitorMessage(message, session) {
+    const embed = {
+      author: {
+        name: session.visitorId,
+        icon_url: this.avatarUrl
+      },
+      description: message.content,
+      color: 5763719,
+      // Green
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    let replyToMessageId;
+    if (message.replyTo) {
+      const storage = this.pocketping?.getStorage();
+      if (storage?.getBridgeMessageIds) {
+        const ids = await storage.getBridgeMessageIds(message.replyTo);
+        if (ids?.discordMessageId) {
+          replyToMessageId = ids.discordMessageId;
+        }
+      }
+    }
+    try {
+      const messageId = await this.sendEmbed(embed, replyToMessageId);
+      return { messageId };
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send visitor message:", error);
+      return {};
+    }
+  }
+  /**
+   * Called when an operator sends a message (for cross-bridge sync)
+   */
+  async onOperatorMessage(message, _session, sourceBridge, operatorName) {
+    if (sourceBridge === "discord") {
+      return;
+    }
+    const embed = {
+      author: {
+        name: operatorName || "Operator",
+        icon_url: this.avatarUrl
+      },
+      description: message.content,
+      color: 16705372,
+      // Yellow
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await this.sendEmbed(embed);
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send operator message:", error);
+    }
+  }
+  /**
+   * Called when visitor starts/stops typing
+   */
+  async onTyping(_sessionId, isTyping) {
+    if (!isTyping || this.mode !== "bot" || !this.channelId) return;
+    try {
+      await fetch(
+        `https://discord.com/api/v10/channels/${this.channelId}/typing`,
+        {
+          method: "POST",
+          headers: { Authorization: `Bot ${this.botToken}` }
+        }
+      );
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send typing indicator:", error);
+    }
+  }
+  /**
+   * Called when a visitor edits their message.
+   * @returns true if edit succeeded, false otherwise
+   */
+  async onMessageEdit(_messageId, newContent, bridgeMessageId) {
+    try {
+      if (this.mode === "webhook" && this.webhookUrl) {
+        const response = await fetch(
+          `${this.webhookUrl}/messages/${bridgeMessageId}`,
+          {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              embeds: [
+                {
+                  description: `${newContent}
+
+*(edited)*`,
+                  color: 5763719
+                }
+              ]
+            })
+          }
+        );
+        return response.ok;
+      } else if (this.mode === "bot" && this.channelId) {
+        const response = await fetch(
+          `https://discord.com/api/v10/channels/${this.channelId}/messages/${bridgeMessageId}`,
+          {
+            method: "PATCH",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bot ${this.botToken}`
+            },
+            body: JSON.stringify({
+              embeds: [
+                {
+                  description: `${newContent}
+
+*(edited)*`,
+                  color: 5763719
+                }
+              ]
+            })
+          }
+        );
+        return response.ok;
+      }
+      return false;
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to edit message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a visitor deletes their message.
+   * @returns true if delete succeeded, false otherwise
+   */
+  async onMessageDelete(_messageId, bridgeMessageId) {
+    try {
+      if (this.mode === "webhook" && this.webhookUrl) {
+        const response = await fetch(
+          `${this.webhookUrl}/messages/${bridgeMessageId}`,
+          { method: "DELETE" }
+        );
+        return response.ok || response.status === 404;
+      } else if (this.mode === "bot" && this.channelId) {
+        const response = await fetch(
+          `https://discord.com/api/v10/channels/${this.channelId}/messages/${bridgeMessageId}`,
+          {
+            method: "DELETE",
+            headers: { Authorization: `Bot ${this.botToken}` }
+          }
+        );
+        return response.ok || response.status === 404;
+      }
+      return false;
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to delete message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a custom event is triggered from the widget
+   */
+  async onCustomEvent(event, session) {
+    const embed = {
+      title: `Custom Event: ${event.name}`,
+      color: 15418782,
+      // Fuchsia
+      fields: [
+        { name: "Visitor", value: session.visitorId, inline: true },
+        ...event.data ? [
+          {
+            name: "Data",
+            value: `\`\`\`json
+${JSON.stringify(event.data, null, 2)}
+\`\`\``,
+            inline: false
+          }
+        ] : []
+      ],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await this.sendEmbed(embed);
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send custom event:", error);
+    }
+  }
+  /**
+   * Called when a user identifies themselves via PocketPing.identify()
+   */
+  async onIdentityUpdate(session) {
+    if (!session.identity) return;
+    const identity = session.identity;
+    const fields = [
+      { name: "User ID", value: identity.id, inline: true }
+    ];
+    if (identity.name) {
+      fields.push({ name: "Name", value: identity.name, inline: true });
+    }
+    if (identity.email) {
+      fields.push({ name: "Email", value: identity.email, inline: true });
+    }
+    const embed = {
+      title: "User Identified",
+      color: 5793266,
+      fields,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      await this.sendEmbed(embed);
+    } catch (error) {
+      console.error("[DiscordBridge] Failed to send identity update:", error);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Private helper methods
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Send an embed to Discord
+   */
+  async sendEmbed(embed, replyToMessageId) {
+    const body = {
+      embeds: [embed]
+    };
+    if (this.username) {
+      body.username = this.username;
+    }
+    if (this.avatarUrl) {
+      body.avatar_url = this.avatarUrl;
+    }
+    if (this.mode === "webhook" && this.webhookUrl) {
+      if (replyToMessageId) {
+        body.message_reference = { message_id: replyToMessageId };
+      }
+      const response = await fetch(`${this.webhookUrl}?wait=true`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord webhook error: ${error}`);
+      }
+      const data = await response.json();
+      return data.id;
+    } else if (this.mode === "bot" && this.channelId) {
+      if (replyToMessageId) {
+        body.message_reference = { message_id: replyToMessageId };
+      }
+      const response = await fetch(
+        `https://discord.com/api/v10/channels/${this.channelId}/messages`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bot ${this.botToken}`
+          },
+          body: JSON.stringify(body)
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Discord API error: ${error}`);
+      }
+      const data = await response.json();
+      return data.id;
+    }
+    return void 0;
+  }
+};
+
+// src/bridges/slack.ts
+var SlackBridge = class _SlackBridge {
+  constructor(config) {
+    this.name = "slack";
+    this.mode = config.mode;
+    this.webhookUrl = config.webhookUrl;
+    this.botToken = config.botToken;
+    this.channelId = config.channelId;
+    this.username = config.username;
+    this.iconEmoji = config.iconEmoji;
+    this.iconUrl = config.iconUrl;
+  }
+  /**
+   * Create a Slack bridge using a webhook URL
+   */
+  static webhook(webhookUrl, options = {}) {
+    return new _SlackBridge({
+      mode: "webhook",
+      webhookUrl,
+      username: options.username,
+      iconEmoji: options.iconEmoji,
+      iconUrl: options.iconUrl
+    });
+  }
+  /**
+   * Create a Slack bridge using a bot token
+   */
+  static bot(botToken, channelId, options = {}) {
+    return new _SlackBridge({
+      mode: "bot",
+      botToken,
+      channelId,
+      username: options.username,
+      iconEmoji: options.iconEmoji,
+      iconUrl: options.iconUrl
+    });
+  }
+  /**
+   * Initialize the bridge (optional setup)
+   */
+  async init(pocketping) {
+    this.pocketping = pocketping;
+    if (this.mode === "bot" && this.botToken) {
+      try {
+        const response = await fetch("https://slack.com/api/auth.test", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.botToken}`
+          }
+        });
+        const data = await response.json();
+        if (!data.ok) {
+          console.error("[SlackBridge] Invalid bot token:", data.error);
+        }
+      } catch (error) {
+        console.error("[SlackBridge] Failed to verify bot token:", error);
+      }
+    }
+  }
+  /**
+   * Called when a new chat session is created
+   */
+  async onNewSession(session) {
+    const url = session.metadata?.url || "Unknown page";
+    const blocks = [
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "New chat session",
+          emoji: true
+        }
+      },
+      {
+        type: "section",
+        fields: [
+          {
+            type: "mrkdwn",
+            text: `*Visitor:*
+${session.visitorId}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Page:*
+${url}`
+          }
+        ]
+      }
+    ];
+    try {
+      await this.sendBlocks(blocks);
+    } catch (error) {
+      console.error("[SlackBridge] Failed to send new session notification:", error);
+    }
+  }
+  /**
+   * Called when a visitor sends a message.
+   * Returns the Slack message timestamp for edit/delete sync.
+   */
+  async onVisitorMessage(message, session) {
+    const blocks = [];
+    if (message.replyTo && this.pocketping?.getStorage().getMessage) {
+      const replyTarget = await this.pocketping.getStorage().getMessage(message.replyTo);
+      if (replyTarget) {
+        const senderLabel = replyTarget.sender === "visitor" ? "Visitor" : replyTarget.sender === "operator" ? "Support" : "AI";
+        const rawPreview = replyTarget.deletedAt ? "Message deleted" : replyTarget.content || "Message";
+        const preview = rawPreview.length > 140 ? `${rawPreview.slice(0, 140)}...` : rawPreview;
+        const quoted = `> *${this.escapeSlack(senderLabel)}* \u2014 ${this.escapeSlack(preview)}`;
+        blocks.push({
+          type: "section",
+          text: {
+            type: "mrkdwn",
+            text: quoted
+          }
+        });
+      }
+    }
+    blocks.push(
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*${this.escapeSlack(session.visitorId)}:*
+${this.escapeSlack(message.content)}`
+        }
+      },
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: `<!date^${Math.floor(Date.now() / 1e3)}^{date_short_pretty} at {time}|${(/* @__PURE__ */ new Date()).toISOString()}>`
+          }
+        ]
+      }
+    );
+    try {
+      const messageId = await this.sendBlocks(blocks);
+      return { messageId };
+    } catch (error) {
+      console.error("[SlackBridge] Failed to send visitor message:", error);
+      return {};
+    }
+  }
+  /**
+   * Called when an operator sends a message (for cross-bridge sync)
+   */
+  async onOperatorMessage(message, _session, sourceBridge, operatorName) {
+    if (sourceBridge === "slack") {
+      return;
+    }
+    const name = operatorName || "Operator";
+    const blocks = [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*${this.escapeSlack(name)}:*
+${this.escapeSlack(message.content)}`
+        }
+      }
+    ];
+    try {
+      await this.sendBlocks(blocks);
+    } catch (error) {
+      console.error("[SlackBridge] Failed to send operator message:", error);
+    }
+  }
+  /**
+   * Called when visitor starts/stops typing
+   */
+  async onTyping(_sessionId, _isTyping) {
+  }
+  /**
+   * Called when a visitor edits their message.
+   * @returns true if edit succeeded, false otherwise
+   */
+  async onMessageEdit(_messageId, newContent, bridgeMessageId) {
+    if (this.mode !== "bot" || !this.channelId) {
+      console.warn("[SlackBridge] Message edit only supported in bot mode");
+      return false;
+    }
+    try {
+      const response = await fetch("https://slack.com/api/chat.update", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.botToken}`
+        },
+        body: JSON.stringify({
+          channel: this.channelId,
+          ts: bridgeMessageId,
+          blocks: [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `${this.escapeSlack(newContent)}
+
+_(edited)_`
+              }
+            }
+          ]
+        })
+      });
+      const data = await response.json();
+      if (!data.ok) {
+        console.error("[SlackBridge] Edit failed:", data.error);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("[SlackBridge] Failed to edit message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a visitor deletes their message.
+   * @returns true if delete succeeded, false otherwise
+   */
+  async onMessageDelete(_messageId, bridgeMessageId) {
+    if (this.mode !== "bot" || !this.channelId) {
+      console.warn("[SlackBridge] Message delete only supported in bot mode");
+      return false;
+    }
+    try {
+      const response = await fetch("https://slack.com/api/chat.delete", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.botToken}`
+        },
+        body: JSON.stringify({
+          channel: this.channelId,
+          ts: bridgeMessageId
+        })
+      });
+      const data = await response.json();
+      if (!data.ok) {
+        if (data.error === "message_not_found") {
+          return true;
+        }
+        console.error("[SlackBridge] Delete failed:", data.error);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("[SlackBridge] Failed to delete message:", error);
+      return false;
+    }
+  }
+  /**
+   * Called when a custom event is triggered from the widget
+   */
+  async onCustomEvent(event, session) {
+    const blocks = [
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: `Custom Event: ${event.name}`,
+          emoji: true
+        }
+      },
+      {
+        type: "section",
+        fields: [
+          {
+            type: "mrkdwn",
+            text: `*Visitor:*
+${session.visitorId}`
+          }
+        ]
+      }
+    ];
+    if (event.data) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Data:*
+\`\`\`${JSON.stringify(event.data, null, 2)}\`\`\``
+        }
+      });
+    }
+    try {
+      await this.sendBlocks(blocks);
+    } catch (error) {
+      console.error("[SlackBridge] Failed to send custom event:", error);
+    }
+  }
+  /**
+   * Called when a user identifies themselves via PocketPing.identify()
+   */
+  async onIdentityUpdate(session) {
+    if (!session.identity) return;
+    const identity = session.identity;
+    const fields = [
+      {
+        type: "mrkdwn",
+        text: `*User ID:*
+${identity.id}`
+      }
+    ];
+    if (identity.name) {
+      fields.push({
+        type: "mrkdwn",
+        text: `*Name:*
+${identity.name}`
+      });
+    }
+    if (identity.email) {
+      fields.push({
+        type: "mrkdwn",
+        text: `*Email:*
+${identity.email}`
+      });
+    }
+    const blocks = [
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: "User Identified",
+          emoji: true
+        }
+      },
+      {
+        type: "section",
+        fields
+      }
+    ];
+    try {
+      await this.sendBlocks(blocks);
+    } catch (error) {
+      console.error("[SlackBridge] Failed to send identity update:", error);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Private helper methods
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Send blocks to Slack
+   */
+  async sendBlocks(blocks) {
+    const payload = { blocks };
+    if (this.username) {
+      payload.username = this.username;
+    }
+    if (this.iconUrl) {
+      payload.icon_url = this.iconUrl;
+    } else if (this.iconEmoji) {
+      payload.icon_emoji = this.iconEmoji;
+    }
+    if (this.mode === "webhook" && this.webhookUrl) {
+      const response = await fetch(this.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Slack webhook error: ${error}`);
+      }
+      return void 0;
+    } else if (this.mode === "bot" && this.channelId) {
+      payload.channel = this.channelId;
+      const response = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.botToken}`
+        },
+        body: JSON.stringify(payload)
+      });
+      const data = await response.json();
+      if (!data.ok) {
+        throw new Error(`Slack API error: ${data.error}`);
+      }
+      return data.ts;
+    }
+    return void 0;
+  }
+  /**
+   * Escape special characters for Slack mrkdwn
+   */
+  escapeSlack(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DiscordBridge,
   MemoryStorage,
-  PocketPing
+  PocketPing,
+  SlackBridge,
+  TelegramBridge,
+  WebhookHandler
 });