@ch4p/cli 0.1.4 → 0.1.5

package/dist/chunk-PAJOAXLQ.js

@@ -0,0 +1,4368 @@
+import {
+  generateId
+} from "./chunk-YSCX2QQQ.js";
+
+// ../../packages/channels/dist/index.js
+import { createInterface } from "readline";
+import WebSocket from "ws";
+import WebSocket2 from "ws";
+import { EventEmitter } from "events";
+import { Socket } from "net";
+import { execFile as execFileCb } from "child_process";
+import { homedir } from "os";
+import { promisify } from "util";
+import { createSign } from "crypto";
+import { connect as netConnect } from "net";
+import { connect as tlsConnect } from "tls";
+import { execFile as execFileCb2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var CliChannel = class {
+  id = "cli";
+  name = "CLI";
+  rl = null;
+  messageHandler = null;
+  running = false;
+  async start(_config) {
+    if (this.running) return;
+    this.rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    this.rl.on("line", (line) => {
+      const text = line.trim();
+      if (!text) return;
+      if (this.messageHandler) {
+        const msg = {
+          id: generateId(),
+          channelId: this.id,
+          from: {
+            channelId: this.id,
+            userId: "cli-user"
+          },
+          text,
+          timestamp: /* @__PURE__ */ new Date(),
+          raw: line
+        };
+        this.messageHandler(msg);
+      }
+    });
+    this.rl.on("close", () => {
+      this.running = false;
+    });
+    this.running = true;
+  }
+  async stop() {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    this.running = false;
+  }
+  async send(_to, message) {
+    try {
+      const output = this.formatOutput(message);
+      process.stdout.write(output + "\n");
+      return {
+        success: true,
+        messageId: generateId()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    return this.running;
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Format an outbound message for terminal display.
+   * When the format is markdown, strip or convert common markdown syntax
+   * to terminal-friendly plain text.
+   */
+  formatOutput(message) {
+    if (message.format === "markdown") {
+      return this.markdownToTerminal(message.text);
+    }
+    if (message.format === "html") {
+      return this.stripHtml(message.text);
+    }
+    return message.text;
+  }
+  /**
+   * Lightweight markdown-to-terminal conversion.
+   * Handles headers, bold, italic, code blocks, inline code, links, and
+   * horizontal rules without pulling in any external dependency.
+   */
+  markdownToTerminal(md) {
+    let text = md;
+    text = text.replace(/```[\s\S]*?\n([\s\S]*?)```/g, (_match, code) => {
+      return code.split("\n").map((line) => `  ${line}`).join("\n");
+    });
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, (_match, heading) => {
+      return `
+${heading.toUpperCase()}
+${"=".repeat(heading.length)}`;
+    });
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
+    text = text.replace(/^[-*_]{3,}$/gm, "---");
+    text = text.replace(/^\s*[-*+]\s+/gm, "  - ");
+    return text.trim();
+  }
+  /** Strip HTML tags, returning plain text. */
+  stripHtml(html) {
+    return html.replace(/<[^>]*>/g, "").trim();
+  }
+};
+function splitMessage(text, maxLen) {
+  if (!text) return [""];
+  if (maxLen < 1) return [text];
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+    const lastSpace = remaining.lastIndexOf(" ", maxLen);
+    const splitAt = lastSpace > maxLen * 0.5 ? lastSpace : maxLen;
+    chunks.push(remaining.slice(0, splitAt).trimEnd());
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}
+function truncateMessage(text, maxLen) {
+  if (maxLen < 1) return text;
+  if (text.length <= maxLen) return text;
+  let end = maxLen - 1;
+  if (end > 0 && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319) {
+    end--;
+  }
+  return text.slice(0, end) + "\u2026";
+}
+function evictOldTimestamps(map, maxEntries) {
+  if (map.size <= maxEntries) return;
+  const sorted = [...map.entries()].sort((a, b) => a[1] - b[1]);
+  const toDelete = Math.max(1, Math.floor(sorted.length / 4));
+  for (let i = 0; i < toDelete; i++) {
+    map.delete(sorted[i][0]);
+  }
+}
+var WEBHOOK_TIMEOUT_MS = 8e3;
+var TELEGRAM_MAX_MESSAGE_LEN = 4096;
+var TELEGRAM_EDIT_RATE_LIMIT_MS = 1e3;
+var TelegramChannel = class _TelegramChannel {
+  id = "telegram";
+  name = "Telegram";
+  token = "";
+  baseUrl = "";
+  messageHandler = null;
+  running = false;
+  pollTimer = null;
+  pollOffset = 0;
+  pollInterval = 1e3;
+  allowedUsers = /* @__PURE__ */ new Set();
+  abortController = null;
+  webhookSecret = null;
+  streamMode = "off";
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.token) {
+      throw new Error('Telegram channel requires a "token" in config');
+    }
+    this.token = cfg.token;
+    this.baseUrl = `https://api.telegram.org/bot${this.token}`;
+    this.pollInterval = cfg.pollInterval ?? 1e3;
+    this.streamMode = cfg.streamMode ?? "off";
+    this.webhookSecret = cfg.webhookSecret ?? null;
+    this.abortController = new AbortController();
+    const userEntries = cfg.allowedUsers ?? [];
+    for (const entry of userEntries) {
+      if (!/^\d+$/.test(entry)) {
+        console.warn(
+          `[Telegram] allowedUsers entry "${entry}" is not a numeric Telegram user ID. Telegram identifies users by numeric ID, not username. This entry may never match.`
+        );
+      }
+    }
+    this.allowedUsers = new Set(userEntries);
+    const me = await this.apiCall("getMe");
+    if (!me) {
+      throw new Error("Failed to verify Telegram bot token (getMe returned null)");
+    }
+    const mode = cfg.mode ?? "polling";
+    if (mode === "webhook") {
+      if (!cfg.webhookUrl) {
+        throw new Error('Webhook mode requires a "webhookUrl" in config');
+      }
+      const webhookParams = { url: cfg.webhookUrl };
+      if (this.webhookSecret) {
+        webhookParams.secret_token = this.webhookSecret;
+      }
+      await this.apiCall("setWebhook", webhookParams);
+    } else {
+      await this.apiCall("deleteWebhook");
+      this.startPolling();
+    }
+    this.running = true;
+  }
+  async stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  async send(to, message) {
+    const chatId = to.userId ?? to.groupId;
+    if (!chatId) {
+      return { success: false, error: "Recipient must have userId or groupId" };
+    }
+    try {
+      const parseMode = message.format === "markdown" ? "MarkdownV2" : message.format === "html" ? "HTML" : void 0;
+      const rawText = parseMode === "MarkdownV2" ? this.escapeMarkdownV2(message.text) : message.text;
+      const chunks = splitMessage(rawText ?? "", TELEGRAM_MAX_MESSAGE_LEN);
+      let lastMessageId;
+      for (const chunk of chunks) {
+        const params = {
+          chat_id: chatId,
+          text: chunk,
+          ...parseMode ? { parse_mode: parseMode } : {},
+          ...message.replyTo && !lastMessageId ? { reply_to_message_id: Number(message.replyTo) } : {},
+          // Thread replies: send into the correct forum topic.
+          ...to.threadId ? { message_thread_id: Number(to.threadId) } : {}
+        };
+        const result = await this.apiCall("sendMessage", params);
+        lastMessageId = result ? String(result.message_id) : void 0;
+      }
+      if (message.attachments?.length) {
+        for (const att of message.attachments) {
+          await this.sendAttachment(chatId, att, to.threadId);
+        }
+      }
+      return {
+        success: true,
+        messageId: lastMessageId ?? generateId()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Edit a previously sent message. Used for progressive streaming updates.
+   * Rate-limited to avoid hitting Telegram API limits.
+   */
+  async editMessage(to, messageId, message) {
+    const chatId = to.userId ?? to.groupId;
+    if (!chatId) {
+      return { success: false, error: "Recipient must have userId or groupId" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    if (lastEdit && now - lastEdit < TELEGRAM_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      const parseMode = message.format === "markdown" ? "MarkdownV2" : message.format === "html" ? "HTML" : void 0;
+      const rawEditText = parseMode === "MarkdownV2" ? this.escapeMarkdownV2(message.text) : message.text;
+      const text = truncateMessage(rawEditText ?? "", TELEGRAM_MAX_MESSAGE_LEN);
+      await this.apiCall("editMessageText", {
+        chat_id: chatId,
+        message_id: Number(messageId),
+        text,
+        ...parseMode ? { parse_mode: parseMode } : {},
+        ...to.threadId ? { message_thread_id: Number(to.threadId) } : {}
+      });
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _TelegramChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    try {
+      const me = await this.apiCall("getMe");
+      return me !== null;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Webhook handler (called by the gateway when a webhook POST arrives)
+  // -----------------------------------------------------------------------
+  /**
+   * Verify the X-Telegram-Bot-Api-Secret-Token header matches our configured secret.
+   * Returns true if no secret is configured (verification disabled) or if the header matches.
+   */
+  verifyWebhookSecret(secretHeader) {
+    if (!this.webhookSecret) return true;
+    return secretHeader === this.webhookSecret;
+  }
+  /**
+   * Process a webhook update from Telegram.
+   * Call this from a gateway route handler when receiving POST /webhook/telegram.
+   *
+   * @param update - The Telegram update object.
+   * @param secretHeader - The X-Telegram-Bot-Api-Secret-Token header value (optional).
+   */
+  handleWebhookUpdate(update, secretHeader) {
+    if (!this.verifyWebhookSecret(secretHeader)) {
+      return;
+    }
+    if (update.message) {
+      this.processMessage(update.message);
+    }
+  }
+  /**
+   * Get the webhook timeout value for gateway-level timeout enforcement.
+   * The gateway should race its HTTP response against this timeout.
+   */
+  static get WEBHOOK_TIMEOUT_MS() {
+    return WEBHOOK_TIMEOUT_MS;
+  }
+  /**
+   * Get the current stream mode configuration.
+   */
+  getStreamMode() {
+    return this.streamMode;
+  }
+  // -----------------------------------------------------------------------
+  // Polling
+  // -----------------------------------------------------------------------
+  startPolling() {
+    if (!this.running && !this.abortController) return;
+    const POLL_CLIENT_TIMEOUT_MS = 35e3;
+    const poll = async () => {
+      if (!this.running) return;
+      try {
+        const deadline = AbortSignal.timeout(POLL_CLIENT_TIMEOUT_MS);
+        const signal = this.abortController ? AbortSignal.any([this.abortController.signal, deadline]) : deadline;
+        const updates = await this.apiCall("getUpdates", {
+          offset: this.pollOffset,
+          timeout: 30,
+          limit: 100
+        }, signal);
+        if (updates && updates.length > 0) {
+          for (const update of updates) {
+            this.pollOffset = update.update_id + 1;
+            if (update.message) {
+              this.processMessage(update.message);
+            }
+          }
+        }
+      } catch {
+      }
+      if (this.running) {
+        this.pollTimer = setTimeout(poll, this.pollInterval);
+      }
+    };
+    this.pollTimer = setTimeout(poll, 0);
+  }
+  // -----------------------------------------------------------------------
+  // Message processing
+  // -----------------------------------------------------------------------
+  processMessage(msg) {
+    if (!this.messageHandler) return;
+    const userId = msg.from ? String(msg.from.id) : "unknown";
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(userId)) {
+      return;
+    }
+    const text = msg.text ?? "";
+    if (!text && !msg.photo && !msg.document && !msg.voice && !msg.audio && !msg.video) return;
+    const attachments = [];
+    if (msg.photo && msg.photo.length > 0) {
+      const largest = msg.photo[msg.photo.length - 1];
+      attachments.push({
+        type: "image",
+        url: largest.file_id,
+        // Will need getFile() to resolve actual URL
+        mimeType: "image/jpeg"
+      });
+    }
+    if (msg.document) {
+      attachments.push({
+        type: "file",
+        url: msg.document.file_id,
+        filename: msg.document.file_name,
+        mimeType: msg.document.mime_type
+      });
+    }
+    if (msg.voice) {
+      attachments.push({
+        type: "audio",
+        url: msg.voice.file_id,
+        mimeType: msg.voice.mime_type ?? "audio/ogg"
+      });
+    }
+    if (msg.audio) {
+      attachments.push({
+        type: "audio",
+        url: msg.audio.file_id,
+        mimeType: msg.audio.mime_type ?? "audio/mpeg",
+        filename: msg.audio.title
+      });
+    }
+    if (msg.video) {
+      attachments.push({
+        type: "video",
+        url: msg.video.file_id,
+        mimeType: msg.video.mime_type ?? "video/mp4"
+      });
+    }
+    const isGroup = msg.chat.type !== "private";
+    const groupId = isGroup ? String(msg.chat.id) : void 0;
+    const threadId = isGroup && msg.is_topic_message && msg.message_thread_id !== void 0 ? String(msg.message_thread_id) : void 0;
+    const inbound = {
+      id: String(msg.message_id),
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId,
+        groupId,
+        threadId
+      },
+      text,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo: msg.reply_to_message ? String(msg.reply_to_message.message_id) : void 0,
+      timestamp: new Date(msg.date * 1e3),
+      raw: msg
+    };
+    this.messageHandler(inbound);
+  }
+  // -----------------------------------------------------------------------
+  // API helpers
+  // -----------------------------------------------------------------------
+  async apiCall(method, params, signal) {
+    const url = `${this.baseUrl}/${method}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: params ? JSON.stringify(params) : void 0,
+      signal: signal ?? this.abortController?.signal
+    });
+    const data = await response.json();
+    if (!data.ok) {
+      throw new Error(`Telegram API error: ${data.description ?? "Unknown error"}`);
+    }
+    return data.result ?? null;
+  }
+  /**
+   * Resolve a Telegram file_id to a downloadable URL.
+   * Uses the getFile API to get the file_path, then constructs the full URL.
+   */
+  async getFileUrl(fileId) {
+    try {
+      const file = await this.apiCall("getFile", { file_id: fileId });
+      if (file?.file_path) {
+        return `https://api.telegram.org/file/bot${this.token}/${file.file_path}`;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Download a Telegram file by its file_id and return the raw Buffer.
+   */
+  async downloadFile(fileId) {
+    const url = await this.getFileUrl(fileId);
+    if (!url) return null;
+    try {
+      const response = await fetch(url, { signal: this.abortController?.signal });
+      if (!response.ok) return null;
+      const arrayBuf = await response.arrayBuffer();
+      const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+      return { data: Buffer.from(arrayBuf), mimeType: contentType };
+    } catch {
+      return null;
+    }
+  }
+  async sendAttachment(chatId, att, threadId) {
+    const isVoice = att.type === "audio" && (att.mimeType === "audio/ogg" || att.mimeType === "audio/ogg; codecs=opus" || att.filename?.endsWith(".ogg") || att.filename?.endsWith(".oga"));
+    let method;
+    let paramKey;
+    if (isVoice) {
+      method = "sendVoice";
+      paramKey = "voice";
+    } else if (att.type === "image") {
+      method = "sendPhoto";
+      paramKey = "photo";
+    } else if (att.type === "audio") {
+      method = "sendAudio";
+      paramKey = "audio";
+    } else if (att.type === "video") {
+      method = "sendVideo";
+      paramKey = "video";
+    } else {
+      method = "sendDocument";
+      paramKey = "document";
+    }
+    await this.apiCall(method, {
+      chat_id: chatId,
+      [paramKey]: att.url ?? att.filename ?? "",
+      ...threadId ? { message_thread_id: Number(threadId) } : {}
+    });
+  }
+  /**
+   * Escape special characters for Telegram MarkdownV2 parse mode.
+   * Telegram requires escaping: _ * [ ] ( ) ~ ` > # + - = | { } . !
+   */
+  escapeMarkdownV2(text) {
+    return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
+  }
+};
+var DISCORD_MAX_MESSAGE_LEN = 2e3;
+var DISCORD_EDIT_RATE_LIMIT_MS = 1e3;
+var DISCORD_RECONNECT_BASE_MS = 1e3;
+var DISCORD_RECONNECT_MAX_MS = 6e4;
+var GatewayOp = {
+  DISPATCH: 0,
+  HEARTBEAT: 1,
+  IDENTIFY: 2,
+  RESUME: 6,
+  RECONNECT: 7,
+  INVALID_SESSION: 9,
+  HELLO: 10,
+  HEARTBEAT_ACK: 11
+};
+var DiscordIntents = {
+  GUILDS: 1 << 0,
+  GUILD_MESSAGES: 1 << 9,
+  GUILD_MESSAGE_TYPING: 1 << 11,
+  DIRECT_MESSAGES: 1 << 12,
+  DIRECT_MESSAGE_TYPING: 1 << 14,
+  MESSAGE_CONTENT: 1 << 15
+};
+var DEFAULT_INTENTS = DiscordIntents.GUILDS | DiscordIntents.GUILD_MESSAGES | DiscordIntents.DIRECT_MESSAGES | DiscordIntents.MESSAGE_CONTENT;
+var API_BASE = "https://discord.com/api/v10";
+var GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+var DiscordChannel = class _DiscordChannel {
+  id = "discord";
+  name = "Discord";
+  token = "";
+  intents = DEFAULT_INTENTS;
+  messageHandler = null;
+  presenceHandler = null;
+  running = false;
+  ws = null;
+  heartbeatTimer = null;
+  sequence = null;
+  sessionId = null;
+  resumeGatewayUrl = null;
+  botUserId = null;
+  allowedGuilds = /* @__PURE__ */ new Set();
+  allowedUsers = /* @__PURE__ */ new Set();
+  streamMode = "off";
+  reconnectAttempts = 0;
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.token) {
+      throw new Error('Discord channel requires a "token" in config');
+    }
+    this.token = cfg.token;
+    this.intents = cfg.intents ?? DEFAULT_INTENTS;
+    this.allowedGuilds = new Set(cfg.allowedGuilds ?? []);
+    this.allowedUsers = new Set(cfg.allowedUsers ?? []);
+    this.streamMode = cfg.streamMode ?? "off";
+    const me = await this.apiCall("/users/@me");
+    this.botUserId = me.id;
+    await this.connectGateway();
+    this.running = true;
+  }
+  async stop() {
+    this.running = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Shutting down");
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  async send(to, message) {
+    const channelId = to.groupId ?? to.threadId ?? to.userId;
+    if (!channelId) {
+      return { success: false, error: "Recipient must have groupId, threadId, or userId (DM channel ID)" };
+    }
+    try {
+      const chunks = splitMessage(message.text ?? "", DISCORD_MAX_MESSAGE_LEN);
+      let lastId;
+      for (const chunk of chunks) {
+        const body = { content: chunk };
+        if (!lastId && message.replyTo) {
+          body.message_reference = { message_id: message.replyTo };
+        }
+        const result = await this.apiCall(
+          `/channels/${channelId}/messages`,
+          "POST",
+          body
+        );
+        lastId = result.id;
+      }
+      return { success: true, messageId: lastId ?? "" };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Edit a previously sent message. Used for progressive streaming updates.
+   * Rate-limited to avoid hitting Discord API limits.
+   */
+  async editMessage(to, messageId, message) {
+    const channelId = to.groupId ?? to.threadId ?? to.userId;
+    if (!channelId) {
+      return { success: false, error: "Recipient must have groupId, threadId, or userId" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    if (lastEdit && now - lastEdit < DISCORD_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      await this.apiCall(
+        `/channels/${channelId}/messages/${messageId}`,
+        "PATCH",
+        { content: truncateMessage(message.text ?? "", DISCORD_MAX_MESSAGE_LEN) }
+      );
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _DiscordChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Get the current stream mode configuration.
+   */
+  getStreamMode() {
+    return this.streamMode;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(handler) {
+    this.presenceHandler = handler;
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    try {
+      await this.apiCall("/users/@me");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Gateway WebSocket
+  // -----------------------------------------------------------------------
+  async connectGateway() {
+    const url = this.resumeGatewayUrl ?? GATEWAY_URL;
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(url);
+      let identified = false;
+      this.ws.on("message", (data) => {
+        try {
+          const payload = JSON.parse(data.toString());
+          if (payload.s !== null) {
+            this.sequence = payload.s;
+          }
+          switch (payload.op) {
+            case GatewayOp.HELLO: {
+              const { heartbeat_interval } = payload.d;
+              this.startHeartbeat(heartbeat_interval);
+              if (this.sessionId && this.sequence !== null) {
+                this.ws.send(JSON.stringify({
+                  op: GatewayOp.RESUME,
+                  d: {
+                    token: this.token,
+                    session_id: this.sessionId,
+                    seq: this.sequence
+                  }
+                }));
+              } else {
+                this.ws.send(JSON.stringify({
+                  op: GatewayOp.IDENTIFY,
+                  d: {
+                    token: this.token,
+                    intents: this.intents,
+                    properties: {
+                      os: "linux",
+                      browser: "ch4p",
+                      device: "ch4p"
+                    }
+                  }
+                }));
+              }
+              break;
+            }
+            case GatewayOp.HEARTBEAT_ACK:
+              break;
+            case GatewayOp.HEARTBEAT:
+              this.sendHeartbeat();
+              break;
+            case GatewayOp.RECONNECT:
+              this.reconnect();
+              break;
+            case GatewayOp.INVALID_SESSION: {
+              const resumable = payload.d;
+              if (!resumable) {
+                this.sessionId = null;
+                this.sequence = null;
+                this.resumeGatewayUrl = null;
+              }
+              this.reconnect();
+              break;
+            }
+            case GatewayOp.DISPATCH:
+              this.handleDispatch(payload.t, payload.d);
+              if (payload.t === "READY") {
+                const ready = payload.d;
+                this.sessionId = ready.session_id;
+                this.resumeGatewayUrl = ready.resume_gateway_url;
+                this.reconnectAttempts = 0;
+                if (!identified) {
+                  identified = true;
+                  resolve();
+                }
+              }
+              break;
+          }
+        } catch {
+        }
+      });
+      this.ws.on("error", (err) => {
+        if (!identified) {
+          reject(err);
+        }
+      });
+      this.ws.on("close", () => {
+        if (this.running) {
+          this.reconnect();
+        }
+      });
+      setTimeout(() => {
+        if (!identified) {
+          reject(new Error("Discord gateway connection timed out"));
+        }
+      }, 3e4);
+    });
+  }
+  startHeartbeat(intervalMs) {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    setTimeout(() => this.sendHeartbeat(), Math.random() * intervalMs);
+    this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), intervalMs);
+  }
+  sendHeartbeat() {
+    if (this.ws?.readyState === 1) {
+      this.ws.send(JSON.stringify({
+        op: GatewayOp.HEARTBEAT,
+        d: this.sequence
+      }));
+    }
+  }
+  reconnect() {
+    this.reconnectAttempts++;
+    const delayMs = Math.min(DISCORD_RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts - 1), DISCORD_RECONNECT_MAX_MS);
+    const jitter = delayMs * 0.2 * (Math.random() * 2 - 1);
+    if (this.ws) {
+      try {
+        this.ws.close(4e3, "Reconnecting");
+      } catch {
+      }
+      this.ws = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.running) {
+      setTimeout(() => {
+        this.connectGateway().catch(() => {
+          this.reconnect();
+        });
+      }, Math.max(0, delayMs + jitter));
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event dispatch
+  // -----------------------------------------------------------------------
+  handleDispatch(event, data) {
+    switch (event) {
+      case "MESSAGE_CREATE":
+        this.handleMessageCreate(data);
+        break;
+      case "TYPING_START":
+        this.handleTypingStart(data);
+        break;
+    }
+  }
+  handleMessageCreate(msg) {
+    if (!this.messageHandler) return;
+    if (msg.author.id === this.botUserId) return;
+    if (msg.author.bot) return;
+    if (msg.guild_id && this.allowedGuilds.size > 0 && !this.allowedGuilds.has(msg.guild_id)) {
+      return;
+    }
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(msg.author.id)) {
+      return;
+    }
+    const attachments = (msg.attachments ?? []).map((a) => ({
+      type: this.classifyAttachment(a.content_type ?? ""),
+      url: a.url,
+      filename: a.filename,
+      mimeType: a.content_type
+    }));
+    const inbound = {
+      id: msg.id,
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: msg.author.id,
+        groupId: msg.channel_id
+      },
+      text: msg.content,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo: msg.message_reference?.message_id,
+      timestamp: new Date(msg.timestamp),
+      raw: msg
+    };
+    this.messageHandler(inbound);
+  }
+  handleTypingStart(event) {
+    if (!this.presenceHandler) return;
+    this.presenceHandler({
+      userId: event.user_id,
+      status: "typing",
+      channelId: event.channel_id
+    });
+  }
+  // -----------------------------------------------------------------------
+  // REST API
+  // -----------------------------------------------------------------------
+  async apiCall(path, method = "GET", body) {
+    const response = await fetch(`${API_BASE}${path}`, {
+      method,
+      headers: {
+        "Authorization": `Bot ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "Unknown error");
+      throw new Error(`Discord API error (${response.status}): ${text}`);
+    }
+    return await response.json();
+  }
+  classifyAttachment(mimeType) {
+    if (mimeType.startsWith("image/")) return "image";
+    if (mimeType.startsWith("audio/")) return "audio";
+    if (mimeType.startsWith("video/")) return "video";
+    return "file";
+  }
+};
+var API_BASE2 = "https://slack.com/api";
+var SLACK_MAX_MESSAGE_LEN = 4e3;
+var SLACK_EDIT_RATE_LIMIT_MS = 1e3;
+var SLACK_RECONNECT_BASE_MS = 1e3;
+var SLACK_RECONNECT_MAX_MS = 6e4;
+var SlackChannel = class _SlackChannel {
+  id = "slack";
+  name = "Slack";
+  botToken = "";
+  appToken = "";
+  signingSecret = "";
+  streamMode = "off";
+  messageHandler = null;
+  presenceHandler = null;
+  running = false;
+  ws = null;
+  botUserId = null;
+  allowedChannels = /* @__PURE__ */ new Set();
+  allowedUsers = /* @__PURE__ */ new Set();
+  pingTimer = null;
+  reconnectAttempts = 0;
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.botToken) {
+      throw new Error('Slack channel requires a "botToken" in config');
+    }
+    this.botToken = cfg.botToken;
+    this.appToken = cfg.appToken ?? "";
+    this.signingSecret = cfg.signingSecret ?? "";
+    this.streamMode = cfg.streamMode ?? "off";
+    this.allowedChannels = new Set(cfg.allowedChannels ?? []);
+    this.allowedUsers = new Set(cfg.allowedUsers ?? []);
+    const auth = await this.apiCall("auth.test");
+    if (!auth.ok) {
+      throw new Error(`Slack auth.test failed: ${auth.error ?? "Unknown error"}`);
+    }
+    this.botUserId = auth.user_id;
+    const mode = cfg.mode ?? (this.appToken ? "socket" : "events");
+    if (mode === "socket") {
+      if (!this.appToken) {
+        throw new Error('Socket Mode requires an "appToken" (xapp-*) in config');
+      }
+      await this.connectSocketMode();
+    }
+    this.running = true;
+  }
+  async stop() {
+    this.running = false;
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(1e3, "Shutting down");
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  async send(to, message) {
+    const channel = to.groupId ?? to.userId;
+    if (!channel) {
+      return { success: false, error: "Recipient must have groupId or userId" };
+    }
+    try {
+      const chunks = splitMessage(message.text ?? "", SLACK_MAX_MESSAGE_LEN);
+      let lastTs;
+      for (const chunk of chunks) {
+        const params = {
+          channel,
+          text: chunk
+        };
+        if (message.format === "markdown" || !message.format) {
+          params.mrkdwn = true;
+        }
+        if (!lastTs && message.replyTo) {
+          params.thread_ts = message.replyTo;
+        }
+        const result = await this.apiCall("chat.postMessage", params);
+        if (!result.ok) {
+          return { success: false, error: result.error ?? "chat.postMessage failed" };
+        }
+        lastTs = result.ts;
+      }
+      if (message.attachments?.length) {
+        for (const att of message.attachments) {
+          await this.uploadFile(channel, att, message.replyTo);
+        }
+      }
+      return {
+        success: true,
+        messageId: lastTs ?? ""
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Edit a previously sent message. Used for progressive streaming updates. */
+  async editMessage(to, messageId, message) {
+    const channel = to.groupId ?? to.userId;
+    if (!channel) {
+      return { success: false, error: "Recipient must have groupId or userId" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    if (lastEdit && now - lastEdit < SLACK_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      const result = await this.apiCall("chat.update", {
+        channel,
+        ts: messageId,
+        text: truncateMessage(message.text ?? "", SLACK_MAX_MESSAGE_LEN)
+      });
+      if (!result.ok) {
+        return { success: false, error: result.error ?? "chat.update failed" };
+      }
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _SlackChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  /** Return the configured stream mode. */
+  getStreamMode() {
+    return this.streamMode;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(handler) {
+    this.presenceHandler = handler;
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    try {
+      const result = await this.apiCall("auth.test");
+      return result.ok === true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Events API webhook handler
+  // -----------------------------------------------------------------------
+  /**
+   * Process an Events API payload from the gateway.
+   * Call this from a gateway route handler when receiving POST /webhook/slack.
+   *
+   * Returns a response body:
+   *   - For url_verification: returns { challenge } for Slack's verification.
+   *   - For event_callback: processes the event and returns { ok: true }.
+   */
+  handleEventsPayload(body) {
+    const type = body.type;
+    if (type === "url_verification") {
+      return {
+        status: 200,
+        body: { challenge: body.challenge }
+      };
+    }
+    if (type === "event_callback") {
+      const event = body.event;
+      if (event) {
+        this.processEvent(event);
+      }
+      return { status: 200, body: { ok: true } };
+    }
+    return { status: 200, body: { ok: true } };
+  }
+  /**
+   * Verify a Slack request signature.
+   * Uses the signing secret to validate that the request came from Slack.
+   */
+  async verifySignature(body, timestamp, signature) {
+    if (!this.signingSecret) return true;
+    const { createHmac } = await import("crypto");
+    const baseString = `v0:${timestamp}:${body}`;
+    const hash = createHmac("sha256", this.signingSecret).update(baseString).digest("hex");
+    const expected = `v0=${hash}`;
+    return expected === signature;
+  }
+  // -----------------------------------------------------------------------
+  // Socket Mode
+  // -----------------------------------------------------------------------
+  async connectSocketMode() {
+    const response = await fetch(`${API_BASE2}/apps.connections.open`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.appToken}`,
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    const data = await response.json();
+    if (!data.ok) {
+      throw new Error(`Socket Mode connection failed: ${data.error ?? "Unknown error"}`);
+    }
+    const wsUrl = data.url;
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket2(wsUrl);
+      let connected = false;
+      this.ws.on("open", () => {
+        connected = true;
+        this.reconnectAttempts = 0;
+        if (this.pingTimer) {
+          clearInterval(this.pingTimer);
+          this.pingTimer = null;
+        }
+        this.pingTimer = setInterval(() => {
+          if (this.ws?.readyState === 1) {
+            this.ws.ping();
+          }
+        }, 3e4);
+        resolve();
+      });
+      this.ws.on("message", (data2) => {
+        try {
+          const envelope = JSON.parse(data2.toString());
+          this.handleSocketEnvelope(envelope);
+        } catch {
+        }
+      });
+      this.ws.on("error", (err) => {
+        if (!connected) {
+          reject(err);
+        }
+      });
+      this.ws.on("close", () => {
+        if (this.running) {
+          this.scheduleReconnect();
+        }
+      });
+      setTimeout(() => {
+        if (!connected) {
+          reject(new Error("Slack Socket Mode connection timed out"));
+        }
+      }, 3e4);
+    });
+  }
+  scheduleReconnect() {
+    this.reconnectAttempts++;
+    const delay = Math.min(SLACK_RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempts - 1), SLACK_RECONNECT_MAX_MS);
+    const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+    setTimeout(() => {
+      if (!this.running) return;
+      this.connectSocketMode().catch(() => {
+        this.scheduleReconnect();
+      });
+    }, Math.max(0, delay + jitter));
+  }
+  handleSocketEnvelope(envelope) {
+    if (envelope.envelope_id && this.ws?.readyState === 1) {
+      this.ws.send(JSON.stringify({
+        envelope_id: envelope.envelope_id
+      }));
+    }
+    if (envelope.type === "events_api" && envelope.payload?.event) {
+      this.processEvent(envelope.payload.event);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event processing
+  // -----------------------------------------------------------------------
+  processEvent(event) {
+    if (event.type === "user_typing" && this.presenceHandler) {
+      this.presenceHandler({
+        userId: event.user ?? "unknown",
+        status: "typing",
+        channelId: event.channel
+      });
+      return;
+    }
+    if (event.type === "message" && !event.subtype) {
+      this.processMessage(event);
+    }
+  }
+  processMessage(event) {
+    if (!this.messageHandler) return;
+    if (event.bot_id) return;
+    if (event.user === this.botUserId) return;
+    const userId = event.user ?? "unknown";
+    if (this.allowedChannels.size > 0 && !this.allowedChannels.has(event.channel)) {
+      return;
+    }
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(userId)) {
+      return;
+    }
+    const attachments = (event.files ?? []).map((f) => ({
+      type: this.classifyFile(f.mimetype),
+      url: f.url_private,
+      filename: f.name,
+      mimeType: f.mimetype
+    }));
+    const inbound = {
+      id: event.ts,
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId,
+        groupId: event.channel,
+        threadId: event.thread_ts
+      },
+      text: event.text ?? "",
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo: event.thread_ts,
+      timestamp: new Date(parseFloat(event.ts) * 1e3),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+  // -----------------------------------------------------------------------
+  // Web API
+  // -----------------------------------------------------------------------
+  async apiCall(method, params) {
+    const response = await fetch(`${API_BASE2}/${method}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.botToken}`,
+        "Content-Type": "application/json; charset=utf-8"
+      },
+      body: params ? JSON.stringify(params) : void 0
+    });
+    return await response.json();
+  }
+  async uploadFile(channel, att, threadTs) {
+    if (att.url) {
+      await this.apiCall("chat.postMessage", {
+        channel,
+        text: `\u{1F4CE} ${att.filename ?? "attachment"}: ${att.url}`,
+        ...threadTs ? { thread_ts: threadTs } : {}
+      });
+    }
+  }
+  classifyFile(mimeType) {
+    if (mimeType.startsWith("image/")) return "image";
+    if (mimeType.startsWith("audio/")) return "audio";
+    if (mimeType.startsWith("video/")) return "video";
+    return "file";
+  }
+};
+var MinimalMatrixClient = class extends EventEmitter {
+  constructor(homeserverUrl, accessToken) {
+    super();
+    this.homeserverUrl = homeserverUrl;
+    this.accessToken = accessToken;
+  }
+  nextBatch = null;
+  abortController = null;
+  running = false;
+  txnCounter = 0;
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /** Resolve the authenticated user's Matrix user ID. */
+  async getUserId() {
+    const res = await this.api("GET", "/_matrix/client/v3/account/whoami");
+    return res.user_id;
+  }
+  /** Start the long-poll sync loop. Resolves after the first sync completes. */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    this.abortController = new AbortController();
+    await this.sync(0);
+    void this.syncLoop().catch((err) => {
+      this.emit("error", err);
+    });
+  }
+  /** Stop the sync loop. */
+  stop() {
+    this.running = false;
+    this.abortController?.abort();
+    this.abortController = null;
+    this.removeAllListeners();
+  }
+  /** Send a room event. Returns the event ID. */
+  async sendMessage(roomId, content) {
+    const txnId = `ch4p_${Date.now()}_${this.txnCounter++}`;
+    const encoded = encodeURIComponent(roomId);
+    const res = await this.api(
+      "PUT",
+      `/_matrix/client/v3/rooms/${encoded}/send/m.room.message/${txnId}`,
+      content
+    );
+    return res.event_id;
+  }
+  /** Edit a previously sent message using the m.replace relation. */
+  async editMessage(roomId, eventId, content) {
+    const newContent = {
+      ...content,
+      "m.new_content": { ...content },
+      "m.relates_to": {
+        rel_type: "m.replace",
+        event_id: eventId
+      }
+    };
+    const txnId = `ch4p_edit_${Date.now()}_${this.txnCounter++}`;
+    const encoded = encodeURIComponent(roomId);
+    const res = await this.api(
+      "PUT",
+      `/_matrix/client/v3/rooms/${encoded}/send/m.room.message/${txnId}`,
+      newContent
+    );
+    return res.event_id;
+  }
+  /** Join a room by ID or alias. */
+  async joinRoom(roomId) {
+    const encoded = encodeURIComponent(roomId);
+    await this.api("POST", `/_matrix/client/v3/join/${encoded}`);
+  }
+  // -----------------------------------------------------------------------
+  // Sync loop
+  // -----------------------------------------------------------------------
+  async syncLoop() {
+    while (this.running) {
+      try {
+        await this.sync(3e4);
+      } catch (err) {
+        if (!this.running) return;
+        this.emit("error", err);
+        await this.sleep(5e3);
+      }
+    }
+  }
+  async sync(timeoutMs) {
+    const params = new URLSearchParams({ timeout: String(timeoutMs) });
+    if (this.nextBatch) {
+      params.set("since", this.nextBatch);
+    }
+    params.set("filter", JSON.stringify({
+      presence: { types: [] },
+      // Ignore global presence.
+      account_data: { types: [] },
+      // Ignore account data.
+      room: {
+        state: { lazy_load_members: true },
+        timeline: { limit: 50 }
+      }
+    }));
+    const data = await this.api(
+      "GET",
+      `/_matrix/client/v3/sync?${params.toString()}`
+    );
+    this.nextBatch = data.next_batch;
+    if (data.rooms?.invite) {
+      for (const roomId of Object.keys(data.rooms.invite)) {
+        this.emit("room.invite", roomId);
+      }
+    }
+    if (data.rooms?.join) {
+      for (const [roomId, room] of Object.entries(data.rooms.join)) {
+        for (const event of room.timeline?.events ?? []) {
+          event.room_id = roomId;
+          if (event.type === "m.room.message") {
+            this.emit("room.message", roomId, event);
+          }
+          this.emit("room.event", roomId, event);
+        }
+        for (const event of room.ephemeral?.events ?? []) {
+          event.room_id = roomId;
+          this.emit("room.event", roomId, event);
+        }
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // HTTP helpers
+  // -----------------------------------------------------------------------
+  async api(method, path, body) {
+    const url = `${this.homeserverUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+    const init = {
+      method,
+      headers,
+      signal: this.abortController?.signal
+    };
+    if (body) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Matrix API ${method} ${path} failed (${res.status}): ${text}`);
+    }
+    return await res.json();
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var MatrixChannel = class _MatrixChannel {
+  id = "matrix";
+  name = "Matrix";
+  client = null;
+  messageHandler = null;
+  presenceHandler = null;
+  running = false;
+  allowedRooms = /* @__PURE__ */ new Set();
+  allowedUsers = /* @__PURE__ */ new Set();
+  botUserId = null;
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.homeserverUrl) {
+      throw new Error('Matrix channel requires a "homeserverUrl" in config');
+    }
+    if (!cfg.accessToken) {
+      throw new Error('Matrix channel requires an "accessToken" in config');
+    }
+    this.allowedRooms = new Set(cfg.allowedRooms ?? []);
+    this.allowedUsers = new Set(cfg.allowedUsers ?? []);
+    this.client = new MinimalMatrixClient(cfg.homeserverUrl, cfg.accessToken);
+    const autoJoin = cfg.autoJoin ?? true;
+    if (autoJoin) {
+      this.client.on("room.invite", (roomId) => {
+        void this.client?.joinRoom(roomId).catch(() => {
+        });
+      });
+    }
+    this.botUserId = await this.client.getUserId();
+    this.client.on("room.message", (roomId, event) => {
+      this.processEvent(roomId, event);
+    });
+    this.client.on("room.event", (roomId, event) => {
+      if (event.type === "m.typing") {
+        this.handleTypingEvent(roomId, event);
+      }
+    });
+    await this.client.start();
+    this.running = true;
+  }
+  async stop() {
+    this.running = false;
+    if (this.client) {
+      this.client.stop();
+      this.client = null;
+    }
+  }
+  async send(to, message) {
+    const roomId = to.groupId ?? to.userId;
+    if (!roomId) {
+      return { success: false, error: "Recipient must have groupId (room ID) or userId" };
+    }
+    if (!this.client) {
+      return { success: false, error: "Matrix client is not running" };
+    }
+    try {
+      const content = {};
+      if (message.format === "markdown" || message.format === "html") {
+        content.msgtype = "m.notice";
+        content.body = message.text;
+        content.format = "org.matrix.custom.html";
+        content.formatted_body = message.format === "html" ? message.text : this.markdownToSimpleHtml(message.text);
+      } else {
+        content.msgtype = "m.text";
+        content.body = message.text;
+      }
+      if (message.replyTo) {
+        content["m.relates_to"] = {
+          "m.in_reply_to": { event_id: message.replyTo }
+        };
+      }
+      const eventId = await this.client.sendMessage(roomId, content);
+      if (message.attachments?.length) {
+        for (const att of message.attachments) {
+          await this.sendAttachment(roomId, att);
+        }
+      }
+      return {
+        success: true,
+        messageId: eventId ?? generateId()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Edit a previously sent message using Matrix m.replace relation. */
+  async editMessage(to, messageId, message) {
+    const roomId = to.groupId ?? to.userId;
+    if (!roomId) {
+      return { success: false, error: "Recipient must have groupId (room ID) or userId" };
+    }
+    if (!this.client) {
+      return { success: false, error: "Matrix client is not running" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    const MATRIX_EDIT_RATE_LIMIT_MS = 1e3;
+    if (lastEdit && now - lastEdit < MATRIX_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      const content = {
+        msgtype: "m.text",
+        body: `* ${message.text}`
+      };
+      const newEventId = await this.client.editMessage(roomId, messageId, content);
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _MatrixChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId: newEventId ?? messageId };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(handler) {
+    this.presenceHandler = handler;
+  }
+  async isHealthy() {
+    if (!this.running || !this.client) return false;
+    try {
+      await this.client.getUserId();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event processing
+  // -----------------------------------------------------------------------
+  processEvent(roomId, event) {
+    if (!this.messageHandler) return;
+    if (event.type !== "m.room.message") return;
+    const sender = event.sender;
+    if (sender === this.botUserId) return;
+    if (this.allowedRooms.size > 0 && !this.allowedRooms.has(roomId)) {
+      return;
+    }
+    if (this.allowedUsers.size > 0 && !this.allowedUsers.has(sender)) {
+      return;
+    }
+    const content = event.content;
+    const msgtype = content.msgtype;
+    const text = content.body ?? "";
+    const attachments = [];
+    if (msgtype === "m.image" || msgtype === "m.audio" || msgtype === "m.video" || msgtype === "m.file") {
+      attachments.push({
+        type: this.classifyMsgtype(msgtype),
+        url: content.url,
+        mimeType: content.info?.mimetype,
+        filename: content.filename ?? content.body
+      });
+    }
+    if (!text && attachments.length === 0) return;
+    const replyTo = content["m.relates_to"]?.["m.in_reply_to"]?.event_id;
+    const inbound = {
+      id: event.event_id,
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: sender,
+        groupId: roomId
+      },
+      text,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo,
+      timestamp: new Date(event.origin_server_ts),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+  handleTypingEvent(roomId, event) {
+    if (!this.presenceHandler) return;
+    const content = event.content;
+    const typingUsers = content.user_ids ?? [];
+    for (const userId of typingUsers) {
+      if (userId === this.botUserId) continue;
+      this.presenceHandler({
+        userId,
+        status: "typing",
+        channelId: roomId
+      });
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  async sendAttachment(roomId, att) {
+    if (!this.client) return;
+    const msgtype = att.type === "image" ? "m.image" : att.type === "audio" ? "m.audio" : att.type === "video" ? "m.video" : "m.file";
+    const content = {
+      msgtype,
+      body: att.filename ?? "attachment",
+      url: att.url ?? ""
+    };
+    if (att.mimeType) {
+      content.info = { mimetype: att.mimeType };
+    }
+    await this.client.sendMessage(roomId, content);
+  }
+  /**
+   * Classify a Matrix msgtype to an Attachment type.
+   *   m.image -> 'image'
+   *   m.audio -> 'audio'
+   *   m.video -> 'video'
+   *   m.file  -> 'file'
+   */
+  classifyMsgtype(msgtype) {
+    switch (msgtype) {
+      case "m.image":
+        return "image";
+      case "m.audio":
+        return "audio";
+      case "m.video":
+        return "video";
+      default:
+        return "file";
+    }
+  }
+  /**
+   * Convert simple markdown to basic HTML for formatted_body.
+   * Handles bold, italic, code, and line breaks.
+   */
+  markdownToSimpleHtml(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>").replace(/`(.+?)`/g, "<code>$1</code>").replace(/\n/g, "<br>");
+  }
+};
+var WA_MAX_MESSAGE_LEN = 4096;
+var WA_EDIT_RATE_LIMIT_MS = 1e3;
+var WhatsAppChannel = class _WhatsAppChannel {
+  id = "whatsapp";
+  name = "WhatsApp";
+  accessToken = "";
+  phoneNumberId = "";
+  verifyToken = "";
+  appSecret = "";
+  apiVersion = "v21.0";
+  allowedNumbers = /* @__PURE__ */ new Set();
+  messageHandler = null;
+  running = false;
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.accessToken) {
+      throw new Error('WhatsApp channel requires an "accessToken" in config');
+    }
+    if (!cfg.phoneNumberId) {
+      throw new Error('WhatsApp channel requires a "phoneNumberId" in config');
+    }
+    if (!cfg.verifyToken) {
+      throw new Error('WhatsApp channel requires a "verifyToken" in config');
+    }
+    this.accessToken = cfg.accessToken;
+    this.phoneNumberId = cfg.phoneNumberId;
+    this.verifyToken = cfg.verifyToken;
+    this.appSecret = cfg.appSecret ?? "";
+    this.apiVersion = cfg.apiVersion ?? "v21.0";
+    this.allowedNumbers = new Set(cfg.allowedNumbers ?? []);
+    this.running = true;
+  }
+  async stop() {
+    this.running = false;
+  }
+  async send(to, message) {
+    const recipient = to.userId;
+    if (!recipient) {
+      return { success: false, error: "Recipient must have a userId (phone number)" };
+    }
+    try {
+      if (message.attachments?.length) {
+        for (const att of message.attachments) {
+          await this.sendAttachment(recipient, att);
+        }
+      }
+      if (message.text) {
+        const chunks = splitMessage(message.text, WA_MAX_MESSAGE_LEN);
+        let lastId;
+        for (const chunk of chunks) {
+          const body = {
+            messaging_product: "whatsapp",
+            to: recipient,
+            type: "text",
+            text: { body: chunk },
+            // Only attach reply context to the first chunk.
+            ...!lastId && message.replyTo ? { context: { message_id: message.replyTo } } : {}
+          };
+          const result = await this.graphApiCall(
+            `${this.phoneNumberId}/messages`,
+            "POST",
+            body
+          );
+          lastId = result?.messages?.[0]?.id ?? lastId;
+        }
+        return {
+          success: true,
+          messageId: lastId ?? generateId()
+        };
+      }
+      return { success: true, messageId: generateId() };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Edit a previously sent message using WhatsApp Cloud API. */
+  async editMessage(to, messageId, message) {
+    const recipient = to.userId;
+    if (!recipient) {
+      return { success: false, error: "Recipient must have a userId (phone number)" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    if (lastEdit && now - lastEdit < WA_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      const safeText = truncateMessage(message.text ?? "", WA_MAX_MESSAGE_LEN);
+      await this.graphApiCall(
+        `${this.phoneNumberId}/messages`,
+        "POST",
+        {
+          messaging_product: "whatsapp",
+          to: recipient,
+          type: "text",
+          text: { body: safeText },
+          context: { message_id: messageId }
+        }
+      );
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _WhatsAppChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    try {
+      const data = await this.graphApiCall(
+        this.phoneNumberId,
+        "GET"
+      );
+      return data?.id !== void 0;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Webhook handlers (called by the gateway)
+  // -----------------------------------------------------------------------
+  /**
+   * Handle the GET webhook verification challenge from Meta.
+   * Call this from a gateway route handler when receiving GET /webhook/whatsapp.
+   *
+   * Returns the challenge string to echo back, or null if verification fails.
+   */
+  handleWebhookVerification(query) {
+    const mode = query["hub.mode"];
+    const token = query["hub.verify_token"];
+    const challenge = query["hub.challenge"];
+    if (mode === "subscribe" && token === this.verifyToken) {
+      return challenge ?? null;
+    }
+    return null;
+  }
+  /**
+   * Process an incoming webhook POST payload from WhatsApp Cloud API.
+   * Call this from a gateway route handler when receiving POST /webhook/whatsapp.
+   */
+  handleWebhookPayload(body) {
+    if (body.object !== "whatsapp_business_account") return;
+    if (!body.entry) return;
+    for (const entry of body.entry) {
+      if (!entry.changes) continue;
+      for (const change of entry.changes) {
+        const value = change.value;
+        if (!value?.messages) continue;
+        const contactNames = /* @__PURE__ */ new Map();
+        if (value.contacts) {
+          for (const contact of value.contacts) {
+            if (contact.wa_id && contact.profile?.name) {
+              contactNames.set(contact.wa_id, contact.profile.name);
+            }
+          }
+        }
+        for (const msg of value.messages) {
+          this.processMessage(msg, contactNames);
+        }
+      }
+    }
+  }
+  /**
+   * Verify webhook payload signature using HMAC-SHA256 with the app secret.
+   * The signature header from Meta is formatted as "sha256=<hex>".
+   *
+   * Uses lazy import of node:crypto (same pattern as Slack adapter).
+   */
+  async verifySignature(rawBody, signature) {
+    if (!this.appSecret) return true;
+    const { createHmac } = await import("crypto");
+    const hash = createHmac("sha256", this.appSecret).update(rawBody).digest("hex");
+    const expected = `sha256=${hash}`;
+    return expected === signature;
+  }
+  // -----------------------------------------------------------------------
+  // Media helpers
+  // -----------------------------------------------------------------------
+  /**
+   * Download media by its Cloud API media ID.
+   * Two-step process: first GET the media URL, then download the binary.
+   *
+   * Returns the raw Buffer and mime type, or null on failure.
+   */
+  async downloadMedia(mediaId) {
+    try {
+      const meta = await this.graphApiCall(mediaId, "GET");
+      if (!meta?.url) return null;
+      const response = await fetch(meta.url, {
+        headers: { Authorization: `Bearer ${this.accessToken}` }
+      });
+      if (!response.ok) return null;
+      const arrayBuf = await response.arrayBuffer();
+      return {
+        data: Buffer.from(arrayBuf),
+        mimeType: meta.mime_type ?? "application/octet-stream"
+      };
+    } catch {
+      return null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Message processing
+  // -----------------------------------------------------------------------
+  processMessage(msg, _contactNames) {
+    if (!this.messageHandler) return;
+    const sender = msg.from;
+    if (this.allowedNumbers.size > 0 && !this.allowedNumbers.has(sender)) {
+      return;
+    }
+    const text = this.extractText(msg);
+    const attachments = this.extractAttachments(msg);
+    if (!text && attachments.length === 0) return;
+    const inbound = {
+      id: msg.id,
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: sender
+      },
+      text,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo: msg.context?.message_id,
+      timestamp: new Date(parseInt(msg.timestamp, 10) * 1e3),
+      raw: msg
+    };
+    this.messageHandler(inbound);
+  }
+  extractText(msg) {
+    switch (msg.type) {
+      case "text":
+        return msg.text?.body ?? "";
+      case "image":
+        return msg.image?.caption ?? "";
+      case "video":
+        return msg.video?.caption ?? "";
+      case "document":
+        return msg.document?.caption ?? "";
+      case "location": {
+        const loc = msg.location;
+        if (!loc) return "";
+        const label = loc.name ? `${loc.name}: ` : "";
+        return `${label}${loc.latitude},${loc.longitude}`;
+      }
+      default:
+        return "";
+    }
+  }
+  extractAttachments(msg) {
+    const attachments = [];
+    if (msg.image) {
+      attachments.push({
+        type: "image",
+        url: msg.image.id,
+        // Cloud API media ID — resolve via downloadMedia()
+        mimeType: msg.image.mime_type
+      });
+    }
+    if (msg.audio) {
+      attachments.push({
+        type: "audio",
+        url: msg.audio.id,
+        mimeType: msg.audio.mime_type
+      });
+    }
+    if (msg.video) {
+      attachments.push({
+        type: "video",
+        url: msg.video.id,
+        mimeType: msg.video.mime_type
+      });
+    }
+    if (msg.document) {
+      attachments.push({
+        type: "file",
+        url: msg.document.id,
+        mimeType: msg.document.mime_type,
+        filename: msg.document.filename
+      });
+    }
+    if (msg.sticker) {
+      attachments.push({
+        type: "image",
+        url: msg.sticker.id,
+        mimeType: msg.sticker.mime_type
+      });
+    }
+    return attachments;
+  }
+  // -----------------------------------------------------------------------
+  // Outbound attachment sending
+  // -----------------------------------------------------------------------
+  async sendAttachment(recipient, att) {
+    if (att.data) {
+      const mediaId = await this.uploadMedia(att);
+      if (!mediaId) return;
+      const waType = this.attachmentTypeToWaType(att.type);
+      const body = {
+        messaging_product: "whatsapp",
+        to: recipient,
+        type: waType,
+        [waType]: { id: mediaId }
+      };
+      await this.graphApiCall(`${this.phoneNumberId}/messages`, "POST", body);
+      return;
+    }
+    if (att.url) {
+      const waType = this.attachmentTypeToWaType(att.type);
+      const mediaObj = { link: att.url };
+      if (att.filename) mediaObj.filename = att.filename;
+      const body = {
+        messaging_product: "whatsapp",
+        to: recipient,
+        type: waType,
+        [waType]: mediaObj
+      };
+      await this.graphApiCall(`${this.phoneNumberId}/messages`, "POST", body);
+    }
+  }
+  attachmentTypeToWaType(type) {
+    switch (type) {
+      case "image":
+        return "image";
+      case "audio":
+        return "audio";
+      case "video":
+        return "video";
+      case "file":
+        return "document";
+    }
+  }
+  /**
+   * Upload binary media to Meta's media endpoint.
+   * Returns the media ID on success, or null on failure.
+   */
+  async uploadMedia(att) {
+    if (!att.data) return null;
+    try {
+      const url = `https://graph.facebook.com/${this.apiVersion}/${this.phoneNumberId}/media`;
+      const boundary = `----ch4p${Date.now()}${Math.random().toString(36).slice(2)}`;
+      const mimeType = att.mimeType ?? "application/octet-stream";
+      const filename = att.filename ?? "upload";
+      const preamble = `--${boundary}\r
+Content-Disposition: form-data; name="messaging_product"\r
+\r
+whatsapp\r
+--${boundary}\r
+Content-Disposition: form-data; name="type"\r
+\r
+${mimeType}\r
+--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${filename}"\r
+Content-Type: ${mimeType}\r
+\r
+`;
+      const epilogue = `\r
+--${boundary}--\r
+`;
+      const preambleBuf = Buffer.from(preamble, "utf-8");
+      const epilogueBuf = Buffer.from(epilogue, "utf-8");
+      const bodyBuf = Buffer.concat([preambleBuf, att.data, epilogueBuf]);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.accessToken}`,
+          "Content-Type": `multipart/form-data; boundary=${boundary}`
+        },
+        body: bodyBuf
+      });
+      const data = await response.json();
+      return data.id ?? null;
+    } catch {
+      return null;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Graph API helper
+  // -----------------------------------------------------------------------
+  async graphApiCall(endpoint, method, body) {
+    const url = `https://graph.facebook.com/${this.apiVersion}/${endpoint}`;
+    const headers = {
+      "Authorization": `Bearer ${this.accessToken}`
+    };
+    const init = { method, headers };
+    if (body && method === "POST") {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, init);
+    const data = await response.json();
+    if (data.error) {
+      const err = data.error;
+      throw new Error(`WhatsApp API error: ${err.message ?? "Unknown error"} (code ${err.code})`);
+    }
+    return data;
+  }
+};
+var SignalChannel = class _SignalChannel {
+  id = "signal";
+  name = "Signal";
+  account = "";
+  host = "localhost";
+  port = 7583;
+  reconnectInterval = 5e3;
+  messageHandler = null;
+  running = false;
+  socket = null;
+  reconnectTimer = null;
+  allowedNumbers = /* @__PURE__ */ new Set();
+  buffer = "";
+  nextRequestId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  lastEditTimestamps = /* @__PURE__ */ new Map();
+  static EDIT_TS_MAX_ENTRIES = 500;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    const cfg = config;
+    if (!cfg.account) {
+      throw new Error('Signal channel requires an "account" (phone number) in config');
+    }
+    this.account = cfg.account;
+    this.host = cfg.host ?? "localhost";
+    this.port = cfg.port ?? 7583;
+    this.reconnectInterval = cfg.reconnectInterval ?? 5e3;
+    this.allowedNumbers = new Set(cfg.allowedNumbers ?? []);
+    await this.connect();
+    this.running = true;
+    try {
+      await this.rpcCall("listContacts", { account: this.account });
+    } catch {
+    }
+  }
+  async stop() {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    for (const [id, pending] of this.pendingRequests) {
+      pending.reject(new Error("Channel stopped"));
+      this.pendingRequests.delete(id);
+    }
+    if (this.socket) {
+      try {
+        this.socket.destroy();
+      } catch {
+      }
+      this.socket = null;
+    }
+    this.buffer = "";
+  }
+  async send(to, message) {
+    const recipient = to.userId ?? to.groupId;
+    if (!recipient) {
+      return { success: false, error: "Recipient must have userId (phone number) or groupId" };
+    }
+    try {
+      const params = {
+        account: this.account,
+        message: message.text
+      };
+      if (to.groupId) {
+        params.groupId = to.groupId;
+      } else {
+        params.recipient = [to.userId];
+      }
+      if (message.replyTo) {
+        params.quoteTimestamp = Number(message.replyTo);
+      }
+      const result = await this.rpcCall("send", params);
+      const resultObj = result;
+      return {
+        success: true,
+        messageId: resultObj?.timestamp ? String(resultObj.timestamp) : generateId()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /** Edit a previously sent message via signal-cli editMessage RPC. */
+  async editMessage(to, messageId, message) {
+    const recipient = to.userId ?? to.groupId;
+    if (!recipient) {
+      return { success: false, error: "Recipient must have userId or groupId" };
+    }
+    const lastEdit = this.lastEditTimestamps.get(messageId);
+    const now = Date.now();
+    const SIGNAL_EDIT_RATE_LIMIT_MS = 1e3;
+    if (lastEdit && now - lastEdit < SIGNAL_EDIT_RATE_LIMIT_MS) {
+      return { success: true, messageId };
+    }
+    try {
+      const params = {
+        account: this.account,
+        targetTimestamp: Number(messageId),
+        message: message.text
+      };
+      if (to.groupId) {
+        params.groupId = to.groupId;
+      } else {
+        params.recipient = [to.userId];
+      }
+      await this.rpcCall("editMessage", params);
+      this.lastEditTimestamps.set(messageId, now);
+      evictOldTimestamps(this.lastEditTimestamps, _SignalChannel.EDIT_TS_MAX_ENTRIES);
+      return { success: true, messageId };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    if (!this.socket || this.socket.destroyed) return false;
+    try {
+      await this.rpcCall("listContacts", { account: this.account });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // TCP connection management
+  // -----------------------------------------------------------------------
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.buffer = "";
+      this.socket = new Socket();
+      let connected = false;
+      this.socket.on("connect", () => {
+        connected = true;
+        resolve();
+      });
+      this.socket.on("data", (chunk) => {
+        this.onData(chunk);
+      });
+      this.socket.on("error", (err) => {
+        if (!connected) {
+          reject(new Error(`Failed to connect to signal-cli at ${this.host}:${this.port}: ${err.message}`));
+        }
+      });
+      this.socket.on("close", () => {
+        this.socket = null;
+        for (const [id, pending] of this.pendingRequests) {
+          pending.reject(new Error("Socket closed"));
+          this.pendingRequests.delete(id);
+        }
+        if (this.running) {
+          this.scheduleReconnect();
+        }
+      });
+      this.socket.connect(this.port, this.host);
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (!this.running) return;
+      try {
+        await this.connect();
+      } catch {
+        if (this.running) {
+          this.scheduleReconnect();
+        }
+      }
+    }, this.reconnectInterval);
+  }
+  // -----------------------------------------------------------------------
+  // Line-delimited JSON-RPC handling
+  // -----------------------------------------------------------------------
+  onData(chunk) {
+    this.buffer += chunk.toString("utf-8");
+    let newlineIdx;
+    while ((newlineIdx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIdx).trim();
+      this.buffer = this.buffer.slice(newlineIdx + 1);
+      if (line.length === 0) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if ("id" in parsed && typeof parsed.id === "number") {
+          this.handleResponse(parsed);
+        } else if ("method" in parsed) {
+          this.handleNotification(parsed);
+        }
+      } catch {
+      }
+    }
+  }
+  handleResponse(response) {
+    const pending = this.pendingRequests.get(response.id);
+    if (!pending) return;
+    this.pendingRequests.delete(response.id);
+    if (response.error) {
+      pending.reject(new Error(
+        `JSON-RPC error ${response.error.code}: ${response.error.message}`
+      ));
+    } else {
+      pending.resolve(response.result);
+    }
+  }
+  handleNotification(notification) {
+    if (notification.method === "receive") {
+      this.processReceiveNotification(notification.params);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Message processing
+  // -----------------------------------------------------------------------
+  processReceiveNotification(params) {
+    if (!this.messageHandler) return;
+    const envelope = params.envelope;
+    if (!envelope) return;
+    const sourceNumber = envelope.sourceNumber;
+    if (!sourceNumber) return;
+    if (this.allowedNumbers.size > 0 && !this.allowedNumbers.has(sourceNumber)) {
+      return;
+    }
+    const dataMessage = envelope.dataMessage;
+    if (!dataMessage) return;
+    const text = dataMessage.message ?? "";
+    if (!text && (!dataMessage.attachments || dataMessage.attachments.length === 0)) {
+      return;
+    }
+    const attachments = [];
+    if (dataMessage.attachments) {
+      for (const att of dataMessage.attachments) {
+        attachments.push({
+          type: this.classifyAttachment(att.contentType ?? ""),
+          url: att.id,
+          filename: att.filename,
+          mimeType: att.contentType
+        });
+      }
+    }
+    const timestamp = dataMessage.timestamp ?? envelope.timestamp ?? Date.now();
+    const inbound = {
+      id: String(timestamp),
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: sourceNumber,
+        groupId: dataMessage.groupInfo?.groupId
+      },
+      text,
+      attachments: attachments.length > 0 ? attachments : void 0,
+      replyTo: dataMessage.quote?.id ? String(dataMessage.quote.id) : void 0,
+      timestamp: new Date(timestamp),
+      raw: params
+    };
+    this.messageHandler(inbound);
+  }
+  // -----------------------------------------------------------------------
+  // JSON-RPC helpers
+  // -----------------------------------------------------------------------
+  rpcCall(method, params) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        reject(new Error("Not connected to signal-cli daemon"));
+        return;
+      }
+      const id = this.nextRequestId++;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      this.pendingRequests.set(id, { resolve, reject });
+      const payload = JSON.stringify(request) + "\n";
+      this.socket.write(payload, "utf-8", (err) => {
+        if (err) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Failed to write to signal-cli socket: ${err.message}`));
+        }
+      });
+    });
+  }
+  classifyAttachment(contentType) {
+    if (contentType.startsWith("image/")) return "image";
+    if (contentType.startsWith("audio/")) return "audio";
+    if (contentType.startsWith("video/")) return "video";
+    return "file";
+  }
+};
+var execFile = promisify(execFileCb);
+var IMESSAGE_EPOCH_MS = Date.UTC(2001, 0, 1);
+function imessageDateToJS(nanoseconds) {
+  return new Date(IMESSAGE_EPOCH_MS + nanoseconds / 1e6);
+}
+function classifyMimeType(mime) {
+  if (!mime) return "file";
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("audio/")) return "audio";
+  if (mime.startsWith("video/")) return "video";
+  return "file";
+}
+var TAPBACK_SEND_MAP = {
+  love: 0,
+  heart: 0,
+  like: 1,
+  thumbsup: 1,
+  dislike: 2,
+  thumbsdown: 2,
+  laugh: 3,
+  haha: 3,
+  emphasis: 4,
+  exclamation: 4,
+  question: 5
+};
+var TAPBACK_TYPES = {
+  2e3: { name: "love", isRemove: false },
+  2001: { name: "like", isRemove: false },
+  2002: { name: "dislike", isRemove: false },
+  2003: { name: "laugh", isRemove: false },
+  2004: { name: "emphasis", isRemove: false },
+  2005: { name: "question", isRemove: false },
+  3e3: { name: "love", isRemove: true },
+  3001: { name: "like", isRemove: true },
+  3002: { name: "dislike", isRemove: true },
+  3003: { name: "laugh", isRemove: true },
+  3004: { name: "emphasis", isRemove: true },
+  3005: { name: "question", isRemove: true }
+};
+function isReaction(associatedMessageType) {
+  if (associatedMessageType === null || associatedMessageType === 0) return false;
+  return associatedMessageType in TAPBACK_TYPES;
+}
+var IMessageChannel = class {
+  id = "imessage";
+  name = "iMessage";
+  messageHandler = null;
+  running = false;
+  pollTimer = null;
+  pollInterval = 2e3;
+  lastRowId = 0;
+  dbPath = "";
+  allowedHandles = /* @__PURE__ */ new Set();
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    if (process.platform !== "darwin") {
+      throw new Error(
+        `IMessageChannel is macOS-only. Current platform "${process.platform}" is not supported.`
+      );
+    }
+    const cfg = config;
+    try {
+      await execFile("which", ["sqlite3"]);
+    } catch {
+      throw new Error(
+        "sqlite3 CLI not found on PATH. It ships with macOS by default -- ensure your system is not missing it or that PATH is configured correctly."
+      );
+    }
+    this.pollInterval = Math.max(100, cfg.pollInterval ?? 2e3);
+    this.allowedHandles = new Set(cfg.allowedHandles ?? []);
+    this.dbPath = cfg.dbPath ?? `${homedir()}/Library/Messages/chat.db`;
+    try {
+      const { stdout } = await execFile("sqlite3", [
+        "-json",
+        this.dbPath,
+        "SELECT MAX(ROWID) as max_id FROM message;"
+      ]);
+      const rows = JSON.parse(stdout || "[]");
+      this.lastRowId = rows[0]?.max_id ?? 0;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("unable to open database") || message.includes("permission denied") || message.includes("not authorized")) {
+        throw new Error(
+          `Cannot read iMessage database. Grant Full Disk Access to your terminal:
+System Settings > Privacy & Security > Full Disk Access
+Database path: ${this.dbPath}`
+        );
+      }
+      throw new Error(`Failed to query iMessage database: ${message}`);
+    }
+    this.running = true;
+    this.startPolling();
+  }
+  async stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  async send(to, message) {
+    const handle = to.userId;
+    const group = to.groupId;
+    if (!handle && !group) {
+      return { success: false, error: "Recipient must have userId (handle) or groupId (chat name)" };
+    }
+    try {
+      const escapedText = message.text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+      let jxa;
+      if (group) {
+        const escapedGroup = group.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        jxa = [
+          'const app = Application("Messages");',
+          `const chat = app.chats.whose({name: "${escapedGroup}"})[0];`,
+          `app.send("${escapedText}", {to: chat});`
+        ].join("\n");
+      } else {
+        const escapedHandle = handle.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        jxa = [
+          'const app = Application("Messages");',
+          `const buddy = app.buddies.whose({handle: "${escapedHandle}"})[0];`,
+          `app.send("${escapedText}", {to: buddy});`
+        ].join("\n");
+      }
+      await execFile("osascript", ["-l", "JavaScript", "-e", jxa]);
+      return {
+        success: true,
+        messageId: generateId()
+      };
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("not authorized") || errMsg.includes("assistive access")) {
+        return {
+          success: false,
+          error: "Automation permission denied. Allow your terminal to control Messages.app:\nSystem Settings > Privacy & Security > Automation"
+        };
+      }
+      return {
+        success: false,
+        error: errMsg
+      };
+    }
+  }
+  /**
+   * Send a tapback reaction to a specific message via JXA UI scripting.
+   *
+   * Uses System Events accessibility API to:
+   *   1. Look up the message text + chat identifier from chat.db by GUID.
+   *   2. Focus the conversation in Messages.app.
+   *   3. Right-click the target message bubble.
+   *   4. Select the tapback from the context menu.
+   *
+   * Requires macOS 13+ and Accessibility permission for your terminal in
+   * System Settings > Privacy & Security > Accessibility.
+   *
+   * Valid reactionTypes: love, heart, like, thumbsup, dislike, thumbsdown,
+   *   laugh, haha, emphasis, exclamation, question.
+   */
+  async sendReaction(_to, messageGuid, reactionType) {
+    const reactionIndex = TAPBACK_SEND_MAP[reactionType.toLowerCase()];
+    if (reactionIndex === void 0) {
+      const valid = Object.keys(TAPBACK_SEND_MAP).join(", ");
+      return {
+        success: false,
+        error: `Unknown reaction type "${reactionType}". Valid types: ${valid}.`
+      };
+    }
+    const info = await this.getMessageInfo(messageGuid);
+    if (!info) {
+      return {
+        success: false,
+        error: `Message with GUID "${messageGuid}" not found in chat.db.`
+      };
+    }
+    const jxa = buildTapbackScript(info.chatIdentifier, info.text, reactionIndex);
+    try {
+      await execFile("osascript", ["-l", "JavaScript", "-e", jxa]);
+      return { success: true };
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("not authorized") || errMsg.includes("assistive access")) {
+        return {
+          success: false,
+          error: "Accessibility permission denied. Allow your terminal in System Settings > Privacy & Security > Accessibility."
+        };
+      }
+      return { success: false, error: errMsg };
+    }
+  }
+  /**
+   * Look up the plain text and chat_identifier for a message by GUID from chat.db.
+   * Returns null if the message is not found or the query fails.
+   */
+  async getMessageInfo(guid) {
+    if (!/^[A-Za-z0-9\-:/]+$/.test(guid)) {
+      return null;
+    }
+    const safeGuid = guid.replace(/'/g, "''");
+    const sql = `
+      SELECT m.text, c.chat_identifier
+      FROM message m
+      LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id
+      LEFT JOIN chat c ON cmj.chat_id = c.ROWID
+      WHERE m.guid = '${safeGuid}'
+      LIMIT 1
+    `;
+    try {
+      const { stdout } = await execFile("sqlite3", ["-json", this.dbPath, sql]);
+      const rows = JSON.parse(stdout || "[]");
+      const row = rows[0];
+      if (!row) return null;
+      return {
+        text: row.text ?? "",
+        chatIdentifier: row.chat_identifier ?? ""
+      };
+    } catch {
+      return null;
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    try {
+      await execFile("sqlite3", [this.dbPath, "SELECT 1;"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Polling
+  // -----------------------------------------------------------------------
+  startPolling() {
+    const poll = async () => {
+      if (!this.running) return;
+      try {
+        await this.pollMessages();
+      } catch {
+      }
+      if (this.running) {
+        this.pollTimer = setTimeout(poll, this.pollInterval);
+      }
+    };
+    this.pollTimer = setTimeout(poll, 0);
+  }
+  async pollMessages() {
+    if (!this.messageHandler) return;
+    const query = [
+      "SELECT m.ROWID, m.text, m.date, h.id as handle, m.is_from_me,",
+      "       m.cache_has_attachments,",
+      "       m.associated_message_type, m.associated_message_guid,",
+      "       m.thread_originator_guid, m.destination_caller_id,",
+      "       c.chat_identifier, c.display_name",
+      "FROM message m",
+      "JOIN handle h ON m.handle_id = h.ROWID",
+      "LEFT JOIN chat_message_join cmj ON m.ROWID = cmj.message_id",
+      "LEFT JOIN chat c ON cmj.chat_id = c.ROWID",
+      `WHERE m.ROWID > ${this.lastRowId} AND m.is_from_me = 0`,
+      "ORDER BY m.ROWID ASC;"
+    ].join(" ");
+    const { stdout } = await execFile("sqlite3", ["-json", this.dbPath, query]);
+    if (!stdout || stdout.trim() === "" || stdout.trim() === "[]") return;
+    let rows;
+    try {
+      rows = JSON.parse(stdout);
+    } catch {
+      return;
+    }
+    for (const row of rows) {
+      if (row.ROWID > this.lastRowId) {
+        this.lastRowId = row.ROWID;
+      }
+      if (this.allowedHandles.size > 0 && !this.allowedHandles.has(row.handle)) {
+        continue;
+      }
+      const inbound = await this.processRow(row);
+      if (inbound) {
+        this.messageHandler(inbound);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Message processing
+  // -----------------------------------------------------------------------
+  async processRow(row) {
+    if (isReaction(row.associated_message_type)) {
+      const tapback = TAPBACK_TYPES[row.associated_message_type];
+      if (!tapback) return null;
+      let targetGuid = row.associated_message_guid ?? "";
+      const guidMatch = targetGuid.match(/^(?:p:\d+\/|bp:)(.+)$/);
+      if (guidMatch) {
+        targetGuid = guidMatch[1];
+      }
+      return {
+        id: String(row.ROWID),
+        channelId: this.id,
+        from: {
+          channelId: this.id,
+          userId: row.handle,
+          groupId: row.chat_identifier ?? void 0
+        },
+        text: tapback.isRemove ? `[Removed ${tapback.name} reaction]` : `[${tapback.name} reaction]`,
+        replyTo: targetGuid || void 0,
+        timestamp: imessageDateToJS(row.date),
+        raw: {
+          ...row,
+          reaction: true,
+          reactionType: tapback.name,
+          reactionRemoved: tapback.isRemove
+        }
+      };
+    }
+    const text = row.text ?? "";
+    if (!text && !row.cache_has_attachments) return null;
+    let attachments;
+    if (row.cache_has_attachments) {
+      attachments = await this.fetchAttachments(row.ROWID);
+      if (attachments.length === 0) attachments = void 0;
+    }
+    if (!text && !attachments) return null;
+    const isGroup = row.chat_identifier ? row.chat_identifier.startsWith("chat") : false;
+    return {
+      id: String(row.ROWID),
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: row.handle,
+        groupId: isGroup ? row.chat_identifier ?? void 0 : void 0
+      },
+      text,
+      attachments,
+      // Thread context: if this message is a reply in a thread.
+      replyTo: row.thread_originator_guid ?? void 0,
+      timestamp: imessageDateToJS(row.date),
+      raw: {
+        ...row,
+        destination_caller_id: row.destination_caller_id,
+        display_name: row.display_name
+      }
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Attachment handling
+  // -----------------------------------------------------------------------
+  async fetchAttachments(messageRowId) {
+    const query = [
+      "SELECT a.filename, a.mime_type, a.uti",
+      "FROM attachment a",
+      "JOIN message_attachment_join maj ON a.ROWID = maj.attachment_id",
+      `WHERE maj.message_id = ${messageRowId};`
+    ].join(" ");
+    try {
+      const { stdout } = await execFile("sqlite3", ["-json", this.dbPath, query]);
+      if (!stdout || stdout.trim() === "" || stdout.trim() === "[]") return [];
+      const rows = JSON.parse(stdout);
+      return rows.map((att) => {
+        let filepath = att.filename ?? void 0;
+        if (filepath?.startsWith("~/")) {
+          filepath = `${process.env.HOME}${filepath.slice(1)}`;
+        }
+        return {
+          type: classifyMimeType(att.mime_type),
+          url: filepath ? `file://${filepath}` : void 0,
+          filename: filepath?.split("/").pop(),
+          mimeType: att.mime_type ?? void 0
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+};
+function buildTapbackScript(chatIdentifier, messageText, reactionIndex) {
+  const esc = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\x00/g, "");
+  return `(function() {
+  const app = Application("Messages");
+  app.activate();
+  delay(0.5);
+  const se = Application("System Events");
+  const proc = se.processes.byName("Messages");
+
+  // Select the conversation in the sidebar.
+  try {
+    const sidebar = proc.windows[0].splitterGroups[0].scrollAreas[0];
+    const rows = sidebar.tables[0].rows();
+    for (const row of rows) {
+      try {
+        const label = row.staticTexts[0].value();
+        if (label && label.includes("${esc(chatIdentifier)}")) {
+          row.select();
+          break;
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+  delay(0.3);
+
+  // Find the message bubble.
+  let msgEl = null;
+  const targetText = "${esc(messageText.slice(0, 40))}";
+  try {
+    const msgArea = proc.windows[0].splitterGroups[0].scrollAreas[1];
+    const groups = msgArea.groups();
+    for (const g of groups) {
+      try {
+        const txt = g.staticTexts[0].value();
+        if (txt && txt.includes(targetText)) {
+          msgEl = g;
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+
+  if (!msgEl) return "message_not_found";
+
+  // Right-click the bubble to open the context menu.
+  const pos = msgEl.position();
+  const size = msgEl.size();
+  se.rightClick({ at: [pos[0] + size[0] / 2, pos[1] + size[1] / 2] });
+  delay(0.3);
+
+  // Click "React\u2026" item.
+  try {
+    const menu = proc.windows[0].menus[0];
+    const reactItem = menu.menuItems.byName("React\u2026");
+    reactItem.actions.byName("AXPress").perform();
+    delay(0.2);
+    reactItem.menus[0].menuItems[${reactionIndex}].actions.byName("AXPress").perform();
+  } catch (err) {
+    return "react_menu_error: " + err.toString();
+  }
+
+  return "ok";
+})()`;
+}
+var TOKEN_URL = "https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token";
+var BOT_FRAMEWORK_SCOPE = "https://api.botframework.com/.default";
+var TeamsChannel = class _TeamsChannel {
+  id = "teams";
+  name = "Microsoft Teams";
+  config = null;
+  messageHandler = null;
+  // OAuth token cache.
+  accessToken = null;
+  tokenExpiry = 0;
+  // Service URL → conversation mappings for outbound messages.
+  // Capped to prevent unbounded growth in high-traffic bots.
+  static MAX_SERVICE_URLS = 1e4;
+  serviceUrls = /* @__PURE__ */ new Map();
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.appId || typeof cfg.appId !== "string") {
+      throw new Error("TeamsChannel requires appId in config.");
+    }
+    if (!cfg.appPassword || typeof cfg.appPassword !== "string") {
+      throw new Error("TeamsChannel requires appPassword in config.");
+    }
+    this.config = cfg;
+    await this.getAccessToken();
+  }
+  async stop() {
+    this.messageHandler = null;
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+    this.serviceUrls.clear();
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config) {
+      return { success: false, error: "TeamsChannel not started." };
+    }
+    const serviceUrl = this.serviceUrls.get(to.channelId);
+    if (!serviceUrl) {
+      return { success: false, error: `No service URL known for conversation ${to.channelId}` };
+    }
+    try {
+      const token = await this.getAccessToken();
+      const conversationId = to.channelId;
+      const activity = {
+        type: "message",
+        text: message.text,
+        textFormat: message.format === "markdown" ? "markdown" : "plain"
+      };
+      if (message.replyTo) {
+        activity.replyToId = message.replyTo;
+      }
+      const url = `${serviceUrl}v3/conversations/${encodeURIComponent(conversationId)}/activities`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(activity)
+      });
+      if (!response.ok) {
+        const errText = await response.text().catch(() => "");
+        return { success: false, error: `Teams API ${response.status}: ${errText}` };
+      }
+      const result = await response.json();
+      return { success: true, messageId: result.id };
+    } catch (err) {
+      return { success: false, error: `Teams send failed: ${err.message}` };
+    }
+  }
+  async editMessage(to, messageId, message) {
+    if (!this.config) {
+      return { success: false, error: "TeamsChannel not started." };
+    }
+    const serviceUrl = this.serviceUrls.get(to.channelId);
+    if (!serviceUrl) {
+      return { success: false, error: `No service URL known for conversation ${to.channelId}` };
+    }
+    try {
+      const token = await this.getAccessToken();
+      const conversationId = to.channelId;
+      const activity = {
+        type: "message",
+        id: messageId,
+        text: message.text,
+        textFormat: message.format === "markdown" ? "markdown" : "plain"
+      };
+      const url = `${serviceUrl}v3/conversations/${encodeURIComponent(conversationId)}/activities/${encodeURIComponent(messageId)}`;
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${token}`
+        },
+        body: JSON.stringify(activity)
+      });
+      if (!response.ok) {
+        const errText = await response.text().catch(() => "");
+        return { success: false, error: `Teams edit API ${response.status}: ${errText}` };
+      }
+      return { success: true, messageId };
+    } catch (err) {
+      return { success: false, error: `Teams edit failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    if (!this.config) return false;
+    try {
+      await this.getAccessToken();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound activity handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Process an inbound activity from the Bot Framework webhook.
+   * Called by the gateway's channel webhook route.
+   */
+  handleIncomingActivity(activity) {
+    if (!this.config || !this.messageHandler) return;
+    if (activity.serviceUrl && activity.conversation?.id) {
+      this.serviceUrls.set(activity.conversation.id, activity.serviceUrl);
+      if (this.serviceUrls.size > _TeamsChannel.MAX_SERVICE_URLS) {
+        const oldest = this.serviceUrls.keys().next().value;
+        if (oldest !== void 0) this.serviceUrls.delete(oldest);
+      }
+    }
+    if (activity.type !== "message") return;
+    if (!activity.text) return;
+    if (activity.from?.id === this.config.appId) return;
+    if (this.config.allowedUsers?.length) {
+      const aadId = activity.from?.aadObjectId;
+      if (aadId && !this.config.allowedUsers.includes(aadId)) return;
+    }
+    const conversationId = activity.conversation?.id ?? "";
+    const userId = activity.from?.id ?? "";
+    const inbound = {
+      id: activity.id ?? `teams-${Date.now()}`,
+      channelId: conversationId,
+      from: {
+        channelId: conversationId,
+        userId,
+        groupId: activity.conversation?.isGroup ? conversationId : void 0
+      },
+      text: activity.text,
+      timestamp: activity.timestamp ? new Date(activity.timestamp) : /* @__PURE__ */ new Date(),
+      raw: activity
+    };
+    this.messageHandler(inbound);
+  }
+  // ---------------------------------------------------------------------------
+  // OAuth2 token management
+  // ---------------------------------------------------------------------------
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry - 6e4) {
+      return this.accessToken;
+    }
+    if (!this.config) {
+      throw new Error("TeamsChannel not configured.");
+    }
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.config.appId,
+      client_secret: this.config.appPassword,
+      scope: BOT_FRAMEWORK_SCOPE
+    });
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      throw new Error(`Token request failed (${response.status}): ${errText}`);
+    }
+    const data = await response.json();
+    this.accessToken = data.access_token;
+    this.tokenExpiry = Date.now() + data.expires_in * 1e3;
+    return this.accessToken;
+  }
+};
+var ZALO_MAX_MESSAGE_LEN = 2e3;
+var OA_API_BASE = "https://openapi.zalo.me/v3.0/oa";
+var GRAPH_API_BASE = "https://graph.zalo.me/v2.0";
+var ZaloChannel = class {
+  id = "zalo";
+  name = "Zalo";
+  config = null;
+  messageHandler = null;
+  // Access token cache (tokens expire after ~1 hour).
+  currentAccessToken = null;
+  tokenExpiry = 0;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.oaId || typeof cfg.oaId !== "string") {
+      throw new Error("ZaloChannel requires oaId in config.");
+    }
+    if (!cfg.oaSecretKey || typeof cfg.oaSecretKey !== "string") {
+      throw new Error("ZaloChannel requires oaSecretKey in config.");
+    }
+    if (!cfg.accessToken || typeof cfg.accessToken !== "string") {
+      throw new Error("ZaloChannel requires accessToken in config.");
+    }
+    if (!cfg.appId || typeof cfg.appId !== "string") {
+      throw new Error("ZaloChannel requires appId in config.");
+    }
+    this.config = cfg;
+    this.currentAccessToken = cfg.accessToken;
+    this.tokenExpiry = Date.now() + 3600 * 1e3;
+  }
+  async stop() {
+    this.messageHandler = null;
+    this.currentAccessToken = null;
+    this.tokenExpiry = 0;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config) {
+      return { success: false, error: "ZaloChannel not started." };
+    }
+    const userId = to.userId;
+    if (!userId) {
+      return { success: false, error: "Recipient must have userId for Zalo." };
+    }
+    try {
+      const token = await this.getAccessToken();
+      const chunks = splitMessage(message.text ?? "", ZALO_MAX_MESSAGE_LEN);
+      let lastId;
+      for (const chunk of chunks) {
+        const body = {
+          recipient: { user_id: userId },
+          message: { text: chunk }
+        };
+        const response = await fetch(`${OA_API_BASE}/message/cs`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "access_token": token
+          },
+          body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+          const errText = await response.text().catch(() => "");
+          return { success: false, error: `Zalo API ${response.status}: ${errText}` };
+        }
+        const result = await response.json();
+        if (result.error !== 0) {
+          return { success: false, error: `Zalo API error ${result.error}: ${result.message}` };
+        }
+        lastId = result.data?.message_id ?? lastId;
+      }
+      return { success: true, messageId: lastId };
+    } catch (err) {
+      return { success: false, error: `Zalo send failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    if (!this.config) return false;
+    try {
+      const token = await this.getAccessToken();
+      const response = await fetch(`${OA_API_BASE}/getoa`, {
+        method: "GET",
+        headers: { "access_token": token }
+      });
+      if (!response.ok) return false;
+      const result = await response.json();
+      return result.error === 0;
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound webhook handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Verify a Zalo webhook MAC signature.
+   *
+   * Zalo signs webhooks using SHA-256:
+   *   mac = SHA256(appId + rawBody + timestamp + oaSecretKey)
+   *
+   * The signature is sent in the `mac` field of the event payload.
+   */
+  async verifyWebhookMac(rawBody, mac) {
+    if (!this.config) return false;
+    try {
+      const { createHash } = await import("crypto");
+      const parsed = JSON.parse(rawBody);
+      const appId = parsed.app_id ?? this.config.appId;
+      const timestamp = parsed.timestamp ?? "";
+      const baseString = `${appId}${rawBody}${timestamp}${this.config.oaSecretKey}`;
+      const expected = createHash("sha256").update(baseString).digest("hex");
+      return expected === mac;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Process an inbound webhook event from Zalo.
+   * Called by the gateway's channel webhook route.
+   */
+  handleIncomingEvent(event) {
+    if (!this.config || !this.messageHandler) return;
+    if (event.event_name !== "user_send_text") return;
+    const text = event.message?.text;
+    if (!text) return;
+    const senderId = event.sender?.id ?? "";
+    if (!senderId) return;
+    if (this.config.allowedUsers?.length) {
+      if (!this.config.allowedUsers.includes(senderId)) return;
+    }
+    const inbound = {
+      id: event.message?.msg_id ?? `zalo-${Date.now()}`,
+      channelId: this.id,
+      from: {
+        channelId: this.id,
+        userId: senderId
+      },
+      text,
+      timestamp: event.timestamp ? new Date(parseInt(event.timestamp, 10)) : /* @__PURE__ */ new Date(),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+  // ---------------------------------------------------------------------------
+  // Access token management
+  // ---------------------------------------------------------------------------
+  async getAccessToken() {
+    if (this.currentAccessToken && Date.now() < this.tokenExpiry - 6e4) {
+      return this.currentAccessToken;
+    }
+    if (this.config?.refreshToken && this.config.appSecret) {
+      try {
+        return await this.refreshAccessToken();
+      } catch {
+      }
+    }
+    if (this.currentAccessToken) {
+      return this.currentAccessToken;
+    }
+    throw new Error("ZaloChannel: no valid access token available.");
+  }
+  async refreshAccessToken() {
+    if (!this.config?.refreshToken || !this.config.appSecret) {
+      throw new Error("Cannot refresh: missing refreshToken or appSecret.");
+    }
+    const response = await fetch(`${GRAPH_API_BASE}/me/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        app_id: this.config.appId,
+        grant_type: "refresh_token",
+        refresh_token: this.config.refreshToken,
+        app_secret: this.config.appSecret
+      }).toString()
+    });
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      throw new Error(`Token refresh failed (${response.status}): ${errText}`);
+    }
+    const data = await response.json();
+    if (data.error && data.error !== 0) {
+      throw new Error(`Token refresh error ${data.error}: ${data.message ?? "unknown"}`);
+    }
+    if (!data.access_token) {
+      throw new Error("Token refresh returned no access_token.");
+    }
+    this.currentAccessToken = data.access_token;
+    this.tokenExpiry = Date.now() + (data.expires_in ?? 3600) * 1e3;
+    if (data.refresh_token) {
+      this.config.refreshToken = data.refresh_token;
+    }
+    return this.currentAccessToken;
+  }
+};
+var SEND_TIMEOUT_MS = 15e3;
+var HEALTH_TIMEOUT_MS = 5e3;
+var ZaloPersonalChannel = class {
+  id = "zalo-personal";
+  name = "Zalo Personal";
+  config = null;
+  messageHandler = null;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.bridgeUrl || typeof cfg.bridgeUrl !== "string") {
+      throw new Error("ZaloPersonalChannel requires bridgeUrl in config.");
+    }
+    cfg.bridgeUrl = cfg.bridgeUrl.replace(/\/+$/, "");
+    this.config = cfg;
+    console.warn(
+      "\n\u26A0\uFE0F  Zalo Personal channel uses an unofficial API.\n   Using this channel may violate Zalo's Terms of Service.\n   By enabling this, you accept full responsibility.\n"
+    );
+    try {
+      const healthy = await this.isHealthy();
+      if (!healthy) {
+        console.warn("\u26A0\uFE0F  Zalo Personal bridge is not responding at: " + cfg.bridgeUrl);
+      }
+    } catch {
+      console.warn("\u26A0\uFE0F  Could not reach Zalo Personal bridge at: " + cfg.bridgeUrl);
+    }
+  }
+  async stop() {
+    this.messageHandler = null;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config) {
+      return { success: false, error: "ZaloPersonalChannel not started." };
+    }
+    const target = to.userId ?? to.channelId;
+    if (!target) {
+      return { success: false, error: "No target specified." };
+    }
+    try {
+      const url = `${this.config.bridgeUrl}/send`;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.config.bridgeToken) {
+        headers["Authorization"] = `Bearer ${this.config.bridgeToken}`;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), SEND_TIMEOUT_MS);
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ to: target, text: message.text }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const errText = await response.text().catch(() => "");
+          return { success: false, error: `Bridge send failed (${response.status}): ${errText}` };
+        }
+        const result = await response.json().catch(() => ({}));
+        return { success: true, messageId: result.messageId ?? `zp-${Date.now()}` };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return { success: false, error: `Bridge send timed out after ${SEND_TIMEOUT_MS}ms.` };
+      }
+      return { success: false, error: `Bridge send failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    if (!this.config) return false;
+    try {
+      const url = `${this.config.bridgeUrl}/health`;
+      const headers = {};
+      if (this.config.bridgeToken) {
+        headers["Authorization"] = `Bearer ${this.config.bridgeToken}`;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+      try {
+        const response = await fetch(url, { headers, signal: controller.signal });
+        return response.ok;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound event handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Process an inbound event from the user's Zalo bridge.
+   * Called by the gateway's channel webhook route.
+   */
+  handleIncomingEvent(event) {
+    if (!this.config || !this.messageHandler) return;
+    if (!event.sender || !event.text) return;
+    if (this.config.allowedUsers?.length) {
+      if (!this.config.allowedUsers.includes(event.sender)) return;
+    }
+    const inbound = {
+      id: event.messageId ?? `zp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      channelId: event.threadId ?? event.sender,
+      from: {
+        channelId: event.threadId ?? event.sender,
+        userId: event.sender,
+        groupId: event.threadId
+      },
+      text: event.text,
+      timestamp: event.timestamp ? new Date(event.timestamp) : /* @__PURE__ */ new Date(),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+};
+var API_TIMEOUT_MS = 15e3;
+var HEALTH_TIMEOUT_MS2 = 5e3;
+var BlueBubblesChannel = class {
+  id = "bluebubbles";
+  name = "BlueBubbles";
+  config = null;
+  messageHandler = null;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.host || typeof cfg.host !== "string") {
+      throw new Error("BlueBubblesChannel requires host in config.");
+    }
+    if (!cfg.password || typeof cfg.password !== "string") {
+      throw new Error("BlueBubblesChannel requires password in config.");
+    }
+    cfg.host = cfg.host.replace(/\/+$/, "");
+    this.config = cfg;
+    await this.verifyConnection();
+  }
+  async stop() {
+    this.messageHandler = null;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config) {
+      return { success: false, error: "BlueBubblesChannel not started." };
+    }
+    const chatGuid = to.groupId ?? to.channelId;
+    if (!chatGuid) {
+      return { success: false, error: "No chat GUID specified." };
+    }
+    try {
+      const url = this.apiUrl(`/api/v1/message/text`);
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT_MS);
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            chatGuid,
+            message: message.text,
+            tempGuid: `temp-${Date.now()}`
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const errText = await response.text().catch(() => "");
+          return { success: false, error: `BlueBubbles API ${response.status}: ${errText}` };
+        }
+        const result = await response.json();
+        if (result.status !== 200) {
+          return { success: false, error: result.error?.message ?? result.message };
+        }
+        return { success: true, messageId: result.data?.guid };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return { success: false, error: `BlueBubbles send timed out after ${API_TIMEOUT_MS}ms.` };
+      }
+      return { success: false, error: `BlueBubbles send failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    if (!this.config) return false;
+    try {
+      const url = this.apiUrl("/api/v1/server/info");
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS2);
+      try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) return false;
+        const data = await response.json();
+        return data.status === 200;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound event handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Process an inbound webhook event from BlueBubbles server.
+   * Called by the gateway's channel webhook route.
+   */
+  handleIncomingEvent(event) {
+    if (!this.config || !this.messageHandler) return;
+    if (event.type !== "new-message") return;
+    const data = event.data;
+    if (!data || !data.text) return;
+    if (data.isFromMe) return;
+    const senderAddress = data.handle?.address ?? data.handle?.id ?? "";
+    if (!senderAddress) return;
+    if (this.config.allowedAddresses?.length) {
+      if (!this.config.allowedAddresses.includes(senderAddress)) return;
+    }
+    const chat = data.chats?.[0];
+    const chatGuid = chat?.guid ?? senderAddress;
+    const inbound = {
+      id: data.guid ?? `bb-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      channelId: chatGuid,
+      from: {
+        channelId: chatGuid,
+        userId: senderAddress,
+        groupId: chat?.chatIdentifier?.startsWith("chat") ? chatGuid : void 0
+      },
+      text: data.text,
+      timestamp: data.dateCreated ? new Date(data.dateCreated) : /* @__PURE__ */ new Date(),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Build a full API URL with the password query parameter.
+   */
+  apiUrl(path) {
+    const base = `${this.config.host}${path}`;
+    const separator = base.includes("?") ? "&" : "?";
+    return `${base}${separator}password=${encodeURIComponent(this.config.password)}`;
+  }
+  /**
+   * Verify the BlueBubbles server is reachable on startup.
+   */
+  async verifyConnection() {
+    const healthy = await this.isHealthy();
+    if (!healthy) {
+      throw new Error(
+        `Cannot connect to BlueBubbles server at ${this.config.host}. Ensure the server is running and the password is correct.`
+      );
+    }
+  }
+};
+var GOOGLE_CHAT_MAX_MESSAGE_LEN = 4e3;
+var CHAT_API_BASE = "https://chat.googleapis.com/v1";
+var TOKEN_URL2 = "https://oauth2.googleapis.com/token";
+var CHAT_SCOPE = "https://www.googleapis.com/auth/chat.bot";
+var API_TIMEOUT_MS2 = 15e3;
+var JWT_LIFETIME_S = 3600;
+var GoogleChatChannel = class {
+  id = "googlechat";
+  name = "Google Chat";
+  config = null;
+  messageHandler = null;
+  // Service account credentials (parsed once on start).
+  serviceAccount = null;
+  // OAuth token cache.
+  accessToken = null;
+  tokenExpiry = 0;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.serviceAccountKey || typeof cfg.serviceAccountKey !== "string") {
+      throw new Error("GoogleChatChannel requires serviceAccountKey in config.");
+    }
+    try {
+      this.serviceAccount = JSON.parse(cfg.serviceAccountKey);
+    } catch {
+      throw new Error("GoogleChatChannel: serviceAccountKey must be valid JSON.");
+    }
+    if (!this.serviceAccount.client_email || !this.serviceAccount.private_key) {
+      throw new Error("GoogleChatChannel: serviceAccountKey must contain client_email and private_key.");
+    }
+    this.config = cfg;
+    await this.getAccessToken();
+  }
+  async stop() {
+    this.messageHandler = null;
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+    this.serviceAccount = null;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config || !this.serviceAccount) {
+      return { success: false, error: "GoogleChatChannel not started." };
+    }
+    const spaceName = to.groupId ?? to.channelId;
+    if (!spaceName) {
+      return { success: false, error: "No space specified." };
+    }
+    try {
+      const token = await this.getAccessToken();
+      const url = `${CHAT_API_BASE}/${spaceName}/messages`;
+      const chunks = splitMessage(message.text ?? "", GOOGLE_CHAT_MAX_MESSAGE_LEN);
+      let lastId;
+      for (const chunk of chunks) {
+        const body = { text: chunk };
+        if (to.threadId) {
+          body.thread = { name: to.threadId };
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT_MS2);
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const errText = await response.text().catch(() => "");
+            return { success: false, error: `Google Chat API ${response.status}: ${errText}` };
+          }
+          const result = await response.json();
+          if (result.error) {
+            return { success: false, error: `Google Chat API error: ${result.error.message}` };
+          }
+          lastId = result.name;
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+      return { success: true, messageId: lastId };
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return { success: false, error: `Google Chat send timed out after ${API_TIMEOUT_MS2}ms.` };
+      }
+      return { success: false, error: `Google Chat send failed: ${err.message}` };
+    }
+  }
+  async editMessage(_to, messageId, message) {
+    if (!this.config || !this.serviceAccount) {
+      return { success: false, error: "GoogleChatChannel not started." };
+    }
+    try {
+      const token = await this.getAccessToken();
+      const url = `${CHAT_API_BASE}/${messageId}?updateMask=text`;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT_MS2);
+      try {
+        const response = await fetch(url, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`
+          },
+          body: JSON.stringify({ text: truncateMessage(message.text ?? "", GOOGLE_CHAT_MAX_MESSAGE_LEN) }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const errText = await response.text().catch(() => "");
+          return { success: false, error: `Google Chat edit API ${response.status}: ${errText}` };
+        }
+        return { success: true, messageId };
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return { success: false, error: `Google Chat edit timed out after ${API_TIMEOUT_MS2}ms.` };
+      }
+      return { success: false, error: `Google Chat edit failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    if (!this.config || !this.serviceAccount) return false;
+    try {
+      await this.getAccessToken();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound event handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Process an inbound event from Google Chat webhook.
+   * Called by the gateway's channel webhook route.
+   */
+  handleIncomingEvent(event) {
+    if (!this.config || !this.messageHandler) return;
+    if (this.config.verificationToken && event.token) {
+      if (event.token !== this.config.verificationToken) return;
+    }
+    if (event.type !== "MESSAGE") return;
+    const msg = event.message;
+    if (!msg?.text && !msg?.argumentText) return;
+    if (msg.sender?.type === "BOT") return;
+    const senderEmail = msg.sender?.email ?? "";
+    if (this.config.allowedUsers?.length) {
+      if (senderEmail && !this.config.allowedUsers.includes(senderEmail)) return;
+    }
+    const spaceName = msg.space?.name ?? event.space?.name ?? "";
+    if (this.config.allowedSpaces?.length) {
+      if (spaceName && !this.config.allowedSpaces.includes(spaceName)) return;
+    }
+    const text = msg.argumentText ?? msg.text ?? "";
+    const senderId = msg.sender?.name ?? senderEmail;
+    const inbound = {
+      id: msg.name ?? `gc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      channelId: spaceName,
+      from: {
+        channelId: spaceName,
+        userId: senderId,
+        groupId: msg.space?.type === "ROOM" ? spaceName : void 0,
+        threadId: msg.thread?.name
+      },
+      text,
+      timestamp: msg.createTime ? new Date(msg.createTime) : /* @__PURE__ */ new Date(),
+      raw: event
+    };
+    this.messageHandler(inbound);
+  }
+  // ---------------------------------------------------------------------------
+  // JWT token management
+  // ---------------------------------------------------------------------------
+  /** Get a valid access token, refreshing if needed. */
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry - 6e4) {
+      return this.accessToken;
+    }
+    if (!this.serviceAccount) {
+      throw new Error("GoogleChatChannel not configured.");
+    }
+    const jwt = this.createJwt();
+    const body = new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion: jwt
+    });
+    const tokenUrl = this.serviceAccount.token_uri ?? TOKEN_URL2;
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const errText = await response.text().catch(() => "");
+      throw new Error(`Google token request failed (${response.status}): ${errText}`);
+    }
+    const data = await response.json();
+    this.accessToken = data.access_token;
+    this.tokenExpiry = Date.now() + data.expires_in * 1e3;
+    return this.accessToken;
+  }
+  /** Create a self-signed JWT for the service account. */
+  createJwt() {
+    const now = Math.floor(Date.now() / 1e3);
+    const header = {
+      alg: "RS256",
+      typ: "JWT"
+    };
+    const payload = {
+      iss: this.serviceAccount.client_email,
+      scope: CHAT_SCOPE,
+      aud: this.serviceAccount.token_uri ?? TOKEN_URL2,
+      iat: now,
+      exp: now + JWT_LIFETIME_S
+    };
+    const headerB64 = base64urlEncode(JSON.stringify(header));
+    const payloadB64 = base64urlEncode(JSON.stringify(payload));
+    const signingInput = `${headerB64}.${payloadB64}`;
+    const signer = createSign("RSA-SHA256");
+    signer.update(signingInput);
+    const signature = signer.sign(this.serviceAccount.private_key, "base64");
+    const signatureB64 = signature.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    return `${signingInput}.${signatureB64}`;
+  }
+};
+function base64urlEncode(str) {
+  return Buffer.from(str, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+var WebChatChannel = class {
+  id = "webchat";
+  name = "WebChat";
+  config = null;
+  messageHandler = null;
+  // Map of userId → Set<WebSocket> (supports multiple browser tabs).
+  clients = /* @__PURE__ */ new Map();
+  // Counter for generating anonymous user IDs.
+  anonCounter = 0;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    this.config = config;
+  }
+  async stop() {
+    for (const [, sockets] of this.clients) {
+      for (const ws of sockets) {
+        try {
+          ws.close(1001, "Channel stopping");
+        } catch {
+        }
+      }
+    }
+    this.clients.clear();
+    this.messageHandler = null;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config) {
+      return { success: false, error: "WebChatChannel not started." };
+    }
+    const userId = to.userId ?? to.channelId;
+    const sockets = this.clients.get(userId);
+    if (!sockets || sockets.size === 0) {
+      return { success: false, error: `No WebSocket connection for user ${userId}` };
+    }
+    const messageId = `wc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const payload = {
+      type: "message",
+      id: messageId,
+      text: message.text
+    };
+    const json = JSON.stringify(payload);
+    let sent = false;
+    for (const ws of sockets) {
+      try {
+        if (ws.readyState === 1) {
+          ws.send(json);
+          sent = true;
+        }
+      } catch {
+        sockets.delete(ws);
+      }
+    }
+    return sent ? { success: true, messageId } : { success: false, error: "All WebSocket connections are closed." };
+  }
+  async editMessage(to, messageId, message) {
+    if (!this.config) {
+      return { success: false, error: "WebChatChannel not started." };
+    }
+    const userId = to.userId ?? to.channelId;
+    const sockets = this.clients.get(userId);
+    if (!sockets || sockets.size === 0) {
+      return { success: false, error: `No WebSocket connection for user ${userId}` };
+    }
+    const payload = {
+      type: "edit",
+      messageId,
+      text: message.text
+    };
+    const json = JSON.stringify(payload);
+    let sent = false;
+    for (const ws of sockets) {
+      try {
+        if (ws.readyState === 1) {
+          ws.send(json);
+          sent = true;
+        }
+      } catch {
+        sockets.delete(ws);
+      }
+    }
+    return sent ? { success: true, messageId } : { success: false, error: "All WebSocket connections are closed." };
+  }
+  async isHealthy() {
+    return this.config !== null;
+  }
+  // ---------------------------------------------------------------------------
+  // WebSocket connection management
+  // ---------------------------------------------------------------------------
+  /**
+   * Register a new WebSocket connection.
+   * Called by the gateway's handleUpgrade() when a client connects to /webchat.
+   */
+  handleConnection(ws) {
+    if (!this.config) {
+      ws.close(1013, "Channel not started");
+      return;
+    }
+    let userId = null;
+    const requireAuth = this.config.requireAuth ?? false;
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(typeof data === "string" ? data : data.toString());
+        if (msg.type === "auth") {
+          return;
+        }
+        if (msg.type === "message") {
+          if (!userId) {
+            if (requireAuth && !msg.userId) {
+              this.sendError(ws, "Authentication required.");
+              return;
+            }
+            userId = msg.userId ?? `anon-${++this.anonCounter}`;
+            this.addClient(userId, ws);
+          }
+          if (!msg.text) return;
+          if (!this.messageHandler) return;
+          const inbound = {
+            id: `wc-in-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            channelId: this.id,
+            from: {
+              channelId: this.id,
+              userId
+            },
+            text: msg.text,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.messageHandler(inbound);
+        }
+      } catch {
+        this.sendError(ws, "Invalid message format.");
+      }
+    });
+    ws.on("close", () => {
+      if (userId) {
+        this.removeClient(userId, ws);
+      }
+    });
+    ws.on("error", () => {
+      if (userId) {
+        this.removeClient(userId, ws);
+      }
+    });
+  }
+  /**
+   * Register a WebSocket for a specific userId.
+   * Called when the user is already authenticated via the gateway.
+   */
+  handleAuthenticatedConnection(ws, authenticatedUserId) {
+    if (!this.config) {
+      ws.close(1013, "Channel not started");
+      return;
+    }
+    this.addClient(authenticatedUserId, ws);
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(typeof data === "string" ? data : data.toString());
+        if (msg.type === "message" && msg.text) {
+          if (!this.messageHandler) return;
+          const inbound = {
+            id: `wc-in-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+            channelId: this.id,
+            from: {
+              channelId: this.id,
+              userId: authenticatedUserId
+            },
+            text: msg.text,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          this.messageHandler(inbound);
+        }
+      } catch {
+        this.sendError(ws, "Invalid message format.");
+      }
+    });
+    ws.on("close", () => {
+      this.removeClient(authenticatedUserId, ws);
+    });
+    ws.on("error", () => {
+      this.removeClient(authenticatedUserId, ws);
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  addClient(userId, ws) {
+    let sockets = this.clients.get(userId);
+    if (!sockets) {
+      sockets = /* @__PURE__ */ new Set();
+      this.clients.set(userId, sockets);
+    }
+    sockets.add(ws);
+  }
+  removeClient(userId, ws) {
+    const sockets = this.clients.get(userId);
+    if (sockets) {
+      sockets.delete(ws);
+      if (sockets.size === 0) {
+        this.clients.delete(userId);
+      }
+    }
+  }
+  sendError(ws, error) {
+    try {
+      const payload = { type: "error", error };
+      ws.send(JSON.stringify(payload));
+    } catch {
+    }
+  }
+};
+var DEFAULT_PORT = 6697;
+var DEFAULT_NICK = "ch4p";
+var DEFAULT_RECONNECT_DELAY = 5e3;
+var MAX_IRC_LINE = 512;
+var MAX_PRIVMSG_TEXT = 400;
+var IrcChannel = class {
+  id = "irc";
+  name = "IRC";
+  config = null;
+  messageHandler = null;
+  socket = null;
+  buffer = "";
+  registered = false;
+  stopping = false;
+  reconnectTimer = null;
+  // ---------------------------------------------------------------------------
+  // IChannel lifecycle
+  // ---------------------------------------------------------------------------
+  async start(config) {
+    const cfg = config;
+    if (!cfg.server || typeof cfg.server !== "string") {
+      throw new Error("IrcChannel requires server in config.");
+    }
+    this.config = cfg;
+    this.stopping = false;
+    await this.connect();
+  }
+  async stop() {
+    this.stopping = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.socket) {
+      try {
+        this.rawSend("QUIT :Goodbye");
+      } catch {
+      }
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.registered = false;
+    this.buffer = "";
+    this.messageHandler = null;
+    this.config = null;
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  async send(to, message) {
+    if (!this.config || !this.socket || !this.registered) {
+      return { success: false, error: "IrcChannel not connected." };
+    }
+    const target = to.groupId ?? to.userId ?? to.channelId;
+    if (!target) {
+      return { success: false, error: "No target specified." };
+    }
+    try {
+      const lines = splitMessage2(message.text, MAX_PRIVMSG_TEXT);
+      for (const line of lines) {
+        this.rawSend(`PRIVMSG ${target} :${line}`);
+      }
+      return { success: true, messageId: `irc-${Date.now()}` };
+    } catch (err) {
+      return { success: false, error: `IRC send failed: ${err.message}` };
+    }
+  }
+  async isHealthy() {
+    return this.registered && this.socket !== null && !this.socket.destroyed;
+  }
+  // ---------------------------------------------------------------------------
+  // Connection management
+  // ---------------------------------------------------------------------------
+  async connect() {
+    if (!this.config) throw new Error("Not configured.");
+    const cfg = this.config;
+    const port = cfg.port ?? DEFAULT_PORT;
+    const useSsl = cfg.ssl !== false;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const registrationTimeout = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          this.socket?.destroy();
+          this.socket = null;
+          reject(new Error("IRC registration timeout \u2014 no WELCOME received within 30s"));
+        }
+      }, 3e4);
+      const onConnect = () => {
+        if (cfg.password) {
+          this.rawSend(`PASS ${cfg.password}`);
+        }
+        const nick = cfg.nick ?? DEFAULT_NICK;
+        this.rawSend(`NICK ${nick}`);
+        this.rawSend(`USER ${nick} 0 * :ch4p bot`);
+        clearTimeout(registrationTimeout);
+        settled = true;
+        resolve();
+      };
+      const onError = (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(registrationTimeout);
+          reject(new Error(`IRC connection failed: ${err.message}`));
+        }
+      };
+      if (useSsl) {
+        this.socket = tlsConnect(
+          { host: cfg.server, port, rejectUnauthorized: true },
+          onConnect
+        );
+      } else {
+        this.socket = netConnect({ host: cfg.server, port }, onConnect);
+      }
+      this.socket.setEncoding("utf8");
+      this.socket.on("data", (data) => this.handleData(data));
+      this.socket.on("error", onError);
+      this.socket.on("close", () => this.handleDisconnect());
+    });
+  }
+  scheduleReconnect() {
+    if (this.stopping || !this.config) return;
+    const delay = this.config.reconnectDelay ?? DEFAULT_RECONNECT_DELAY;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.stopping) return;
+      this.registered = false;
+      this.buffer = "";
+      this.connect().catch(() => {
+        this.scheduleReconnect();
+      });
+    }, delay);
+    this.reconnectTimer.unref();
+  }
+  handleDisconnect() {
+    this.registered = false;
+    this.socket = null;
+    if (!this.stopping) {
+      this.scheduleReconnect();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // IRC protocol parsing
+  // ---------------------------------------------------------------------------
+  handleData(data) {
+    this.buffer += data;
+    let newlineIdx;
+    while ((newlineIdx = this.buffer.indexOf("\r\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIdx);
+      this.buffer = this.buffer.slice(newlineIdx + 2);
+      if (line.length > 0) {
+        this.parseLine(line);
+      }
+    }
+  }
+  parseLine(line) {
+    let prefix = "";
+    let rest = line;
+    if (rest.startsWith(":")) {
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx === -1) return;
+      prefix = rest.slice(1, spaceIdx);
+      rest = rest.slice(spaceIdx + 1);
+    }
+    const parts = rest.split(" ");
+    const command = parts[0];
+    if (command === "PING") {
+      const server = parts.slice(1).join(" ");
+      this.rawSend(`PONG ${server}`);
+      return;
+    }
+    if (command === "001") {
+      this.registered = true;
+      const channels = this.config?.channels ?? [];
+      for (const ch of channels) {
+        this.rawSend(`JOIN ${ch}`);
+      }
+      return;
+    }
+    if (command === "PRIVMSG" && parts.length >= 2) {
+      const target = parts[1];
+      const msgStart = rest.indexOf(" :");
+      if (msgStart === -1) return;
+      const text = rest.slice(msgStart + 2);
+      const nick = prefix.split("!")[0] ?? "";
+      if (this.config?.allowedUsers?.length) {
+        if (!this.config.allowedUsers.includes(nick)) return;
+      }
+      if (!this.messageHandler) return;
+      const isChannel = target.startsWith("#") || target.startsWith("&");
+      const inbound = {
+        id: `irc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        channelId: isChannel ? target : nick,
+        from: {
+          channelId: isChannel ? target : nick,
+          userId: nick,
+          groupId: isChannel ? target : void 0
+        },
+        text,
+        timestamp: /* @__PURE__ */ new Date(),
+        raw: { prefix, command, target, text }
+      };
+      this.messageHandler(inbound);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Raw socket I/O
+  // ---------------------------------------------------------------------------
+  rawSend(line) {
+    if (!this.socket || this.socket.destroyed) return;
+    const truncated = line.length > MAX_IRC_LINE - 2 ? line.slice(0, MAX_IRC_LINE - 2) : line;
+    this.socket.write(`${truncated}\r
+`);
+  }
+};
+function splitMessage2(text, maxLen) {
+  if (text.length <= maxLen) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    chunks.push(remaining.slice(0, maxLen));
+    remaining = remaining.slice(maxLen);
+  }
+  return chunks;
+}
+var execFile2 = promisify2(execFileCb2);
+var MacOSChannel = class {
+  id = "macos";
+  name = "macOS Native";
+  messageHandler = null;
+  running = false;
+  mode = "dialog";
+  dialogDelay = 500;
+  title = "ch4p";
+  sound = "Submarine";
+  pendingDialog = null;
+  dialogTimer = null;
+  waitingForResponse = false;
+  // -----------------------------------------------------------------------
+  // IChannel implementation
+  // -----------------------------------------------------------------------
+  async start(config) {
+    if (this.running) return;
+    if (process.platform !== "darwin") {
+      throw new Error(
+        `MacOSChannel is macOS-only. Current platform "${process.platform}" is not supported.`
+      );
+    }
+    try {
+      await execFile2("which", ["osascript"]);
+    } catch {
+      throw new Error(
+        "osascript not found on PATH. This should always be available on macOS."
+      );
+    }
+    const cfg = config;
+    this.mode = cfg.mode ?? "dialog";
+    this.dialogDelay = cfg.dialogDelay ?? 500;
+    this.title = cfg.title ?? "ch4p";
+    this.sound = cfg.sound ?? "Submarine";
+    this.running = true;
+    this.scheduleInputDialog();
+  }
+  async stop() {
+    this.running = false;
+    if (this.dialogTimer) {
+      clearTimeout(this.dialogTimer);
+      this.dialogTimer = null;
+    }
+    if (this.pendingDialog) {
+      try {
+        this.pendingDialog.kill("SIGTERM");
+      } catch {
+      }
+      this.pendingDialog = null;
+    }
+  }
+  async send(_to, message) {
+    if (!this.running) {
+      return { success: false, error: "Channel is not running." };
+    }
+    try {
+      const text = message.text || "(no text)";
+      if (this.mode === "notification") {
+        await this.showNotification(text);
+      } else {
+        await this.showNotification(text);
+      }
+      this.waitingForResponse = false;
+      this.scheduleInputDialog();
+      return {
+        success: true,
+        messageId: generateId()
+      };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onPresence(_handler) {
+  }
+  async isHealthy() {
+    if (!this.running) return false;
+    if (process.platform !== "darwin") return false;
+    try {
+      await execFile2("osascript", ["-e", "1"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Input dialog
+  // -----------------------------------------------------------------------
+  scheduleInputDialog() {
+    if (!this.running || !this.messageHandler || this.waitingForResponse) return;
+    if (this.dialogTimer) {
+      clearTimeout(this.dialogTimer);
+    }
+    this.dialogTimer = setTimeout(() => {
+      this.dialogTimer = null;
+      void this.showInputDialog();
+    }, this.dialogDelay);
+  }
+  async showInputDialog() {
+    if (!this.running || !this.messageHandler) return;
+    try {
+      const script = [
+        `set dialogResult to display dialog "Message for ch4p:" default answer "" with title "${this.escapeAppleScript(this.title)}" buttons {"Cancel", "Send"} default button "Send"`,
+        "return text returned of dialogResult"
+      ].join("\n");
+      const { stdout } = await execFile2("osascript", ["-e", script]);
+      const text = stdout.trim();
+      if (text && this.messageHandler && this.running) {
+        this.waitingForResponse = true;
+        const inbound = {
+          id: generateId(),
+          channelId: this.id,
+          from: {
+            channelId: this.id,
+            userId: "local-user"
+          },
+          text,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        this.messageHandler(inbound);
+      } else {
+        this.scheduleInputDialog();
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("-128") || errMsg.includes("User canceled")) {
+        if (this.running) {
+          this.dialogTimer = setTimeout(() => {
+            this.dialogTimer = null;
+            void this.showInputDialog();
+          }, 5e3);
+        }
+        return;
+      }
+      if (this.running) {
+        this.scheduleInputDialog();
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Notification
+  // -----------------------------------------------------------------------
+  async showNotification(text) {
+    const displayText = text.length > 500 ? text.slice(0, 497) + "..." : text;
+    const escaped = this.escapeAppleScript(displayText);
+    const escapedTitle = this.escapeAppleScript(this.title);
+    const script = `display notification "${escaped}" with title "${escapedTitle}" sound name "${this.sound}"`;
+    await execFile2("osascript", ["-e", script]);
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  /** Escape a string for embedding in an AppleScript string literal. */
+  escapeAppleScript(text) {
+    return text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  }
+};
+var ChannelRegistry = class {
+  channels = /* @__PURE__ */ new Map();
+  /** Register a channel instance. Overwrites if id already exists. */
+  register(channel) {
+    this.channels.set(channel.id, channel);
+  }
+  /** Retrieve a channel by id. */
+  get(id) {
+    return this.channels.get(id);
+  }
+  /** Check whether a channel with the given id is registered. */
+  has(id) {
+    return this.channels.has(id);
+  }
+  /** Return all registered channels. */
+  list() {
+    return [...this.channels.values()];
+  }
+  /** Remove all registered channels. */
+  clear() {
+    this.channels.clear();
+  }
+  /**
+   * Look up a channel by id, call `start()` with the supplied config,
+   * and return the started channel.
+   *
+   * Throws if the channel id is not registered.
+   */
+  async createFromConfig(id, config) {
+    const channel = this.channels.get(id);
+    if (!channel) {
+      throw new Error(`Channel "${id}" is not registered`);
+    }
+    await channel.start(config);
+    return channel;
+  }
+};
+
+export {
+  CliChannel,
+  TelegramChannel,
+  DiscordChannel,
+  SlackChannel,
+  MatrixChannel,
+  WhatsAppChannel,
+  SignalChannel,
+  IMessageChannel,
+  TeamsChannel,
+  ZaloChannel,
+  ZaloPersonalChannel,
+  BlueBubblesChannel,
+  GoogleChatChannel,
+  WebChatChannel,
+  IrcChannel,
+  MacOSChannel,
+  ChannelRegistry
+};