@nextclaw/channel-runtime 0.1.1

package/dist/index.js

@@ -0,0 +1,2658 @@
+// src/channels/base.ts
+var BaseChannel = class {
+  constructor(config, bus) {
+    this.config = config;
+    this.bus = bus;
+  }
+  running = false;
+  isAllowed(senderId) {
+    const allowList = this.config.allowFrom ?? [];
+    if (!allowList.length) {
+      return true;
+    }
+    if (allowList.includes(senderId)) {
+      return true;
+    }
+    if (senderId.includes("|")) {
+      return senderId.split("|").some((part) => allowList.includes(part));
+    }
+    return false;
+  }
+  async handleMessage(params) {
+    if (!this.isAllowed(params.senderId)) {
+      return;
+    }
+    const msg = {
+      channel: this.name,
+      senderId: params.senderId,
+      chatId: params.chatId,
+      content: params.content,
+      timestamp: /* @__PURE__ */ new Date(),
+      attachments: params.attachments ?? [],
+      metadata: params.metadata ?? {}
+    };
+    await this.bus.publishInbound(msg);
+  }
+  get isRunning() {
+    return this.running;
+  }
+};
+
+// src/config/brand.ts
+import {
+  APP_NAME,
+  APP_TITLE,
+  APP_REPLY_SUBJECT
+} from "@nextclaw/core";
+
+// src/channels/dingtalk.ts
+import { DWClient, EventAck, TOPIC_ROBOT } from "dingtalk-stream";
+import { fetch } from "undici";
+var DingTalkChannel = class extends BaseChannel {
+  name = "dingtalk";
+  client = null;
+  accessToken = null;
+  tokenExpiry = 0;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    this.running = true;
+    if (!this.config.clientId || !this.config.clientSecret) {
+      throw new Error("DingTalk clientId/clientSecret not configured");
+    }
+    this.client = new DWClient({
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      debug: false
+    });
+    this.client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
+      await this.handleRobotMessage(res);
+    });
+    this.client.registerAllEventListener(() => ({ status: EventAck.SUCCESS }));
+    await this.client.connect();
+  }
+  async stop() {
+    this.running = false;
+    if (this.client) {
+      this.client.disconnect();
+      this.client = null;
+    }
+  }
+  async send(msg) {
+    const token = await this.getAccessToken();
+    if (!token) {
+      return;
+    }
+    const url = "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
+    const payload = {
+      robotCode: this.config.clientId,
+      userIds: [msg.chatId],
+      msgKey: "sampleMarkdown",
+      msgParam: JSON.stringify({
+        text: msg.content,
+        title: `${APP_TITLE} Reply`
+      })
+    };
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-acs-dingtalk-access-token": token
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`DingTalk send failed: ${response.status}`);
+    }
+  }
+  async handleRobotMessage(res) {
+    if (!res?.data) {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(res.data);
+    } catch {
+      return;
+    }
+    const text = parsed.text?.content?.trim() ?? "";
+    if (!text) {
+      this.client?.socketCallBackResponse(res.headers.messageId, { ok: true });
+      return;
+    }
+    const senderId = parsed.senderStaffId || parsed.senderId || "";
+    const senderName = parsed.senderNick || "";
+    if (!senderId) {
+      this.client?.socketCallBackResponse(res.headers.messageId, { ok: true });
+      return;
+    }
+    await this.handleMessage({
+      senderId,
+      chatId: senderId,
+      content: text,
+      attachments: [],
+      metadata: {
+        sender_name: senderName,
+        platform: "dingtalk"
+      }
+    });
+    this.client?.socketCallBackResponse(res.headers.messageId, { ok: true });
+  }
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+    const url = "https://api.dingtalk.com/v1.0/oauth2/accessToken";
+    const payload = {
+      appKey: this.config.clientId,
+      appSecret: this.config.clientSecret
+    };
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const token = data.accessToken;
+    const expiresIn = Number(data.expireIn ?? 7200);
+    if (!token) {
+      return null;
+    }
+    this.accessToken = token;
+    this.tokenExpiry = Date.now() + (expiresIn - 60) * 1e3;
+    return token;
+  }
+};
+
+// src/channels/discord.ts
+import {
+  Client,
+  GatewayIntentBits,
+  Partials,
+  MessageFlags
+} from "discord.js";
+import { ProxyAgent, fetch as fetch2 } from "undici";
+import { join } from "path";
+import { mkdirSync, writeFileSync } from "fs";
+
+// src/utils/helpers.ts
+import { getDataPath } from "@nextclaw/core";
+
+// src/channels/discord.ts
+var DEFAULT_MEDIA_MAX_MB = 8;
+var MEDIA_FETCH_TIMEOUT_MS = 15e3;
+var DiscordChannel = class extends BaseChannel {
+  name = "discord";
+  client = null;
+  typingTasks = /* @__PURE__ */ new Map();
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.token) {
+      throw new Error("Discord token not configured");
+    }
+    this.running = true;
+    this.client = new Client({
+      intents: this.config.intents ?? GatewayIntentBits.Guilds | GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
+      partials: [Partials.Channel]
+    });
+    this.client.on("ready", () => {
+      console.log("Discord bot connected");
+    });
+    this.client.on("messageCreate", async (message) => {
+      await this.handleIncoming(message);
+    });
+    await this.client.login(this.config.token);
+  }
+  async stop() {
+    this.running = false;
+    for (const task of this.typingTasks.values()) {
+      clearInterval(task);
+    }
+    this.typingTasks.clear();
+    if (this.client) {
+      await this.client.destroy();
+      this.client = null;
+    }
+  }
+  async send(msg) {
+    if (!this.client) {
+      return;
+    }
+    const channel = await this.client.channels.fetch(msg.chatId);
+    if (!channel || !channel.isTextBased()) {
+      return;
+    }
+    this.stopTyping(msg.chatId);
+    const textChannel = channel;
+    const payload = {
+      content: msg.content ?? ""
+    };
+    if (msg.replyTo) {
+      payload.reply = { messageReference: msg.replyTo };
+    }
+    if (msg.metadata?.silent === true) {
+      payload.flags = MessageFlags.SuppressNotifications;
+    }
+    await textChannel.send(payload);
+  }
+  async handleIncoming(message) {
+    const selfUserId = this.client?.user?.id;
+    if (selfUserId && message.author.id === selfUserId) {
+      return;
+    }
+    if (message.author.bot && !this.config.allowBots) {
+      return;
+    }
+    const senderId = message.author.id;
+    const channelId = message.channelId;
+    if (!this.isAllowed(senderId)) {
+      return;
+    }
+    const contentParts = [];
+    const attachments = [];
+    const attachmentIssues = [];
+    if (message.content) {
+      contentParts.push(message.content);
+    }
+    if (message.attachments.size) {
+      const mediaDir = join(getDataPath(), "media");
+      mkdirSync(mediaDir, { recursive: true });
+      const maxBytes = Math.max(1, this.config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB) * 1024 * 1024;
+      const proxy = this.resolveProxyAgent();
+      for (const attachment of message.attachments.values()) {
+        const resolved = await this.resolveInboundAttachment({
+          attachment,
+          mediaDir,
+          maxBytes,
+          proxy
+        });
+        if (resolved.attachment) {
+          attachments.push(resolved.attachment);
+        }
+        if (resolved.issue) {
+          attachmentIssues.push(resolved.issue);
+        }
+      }
+      if (!message.content && attachments.length > 0) {
+        contentParts.push(buildAttachmentSummary(attachments));
+      }
+    }
+    const replyTo = message.reference?.messageId ?? null;
+    this.startTyping(channelId);
+    await this.handleMessage({
+      senderId,
+      chatId: channelId,
+      content: contentParts.length ? contentParts.join("\n") : "[empty message]",
+      attachments,
+      metadata: {
+        message_id: message.id,
+        guild_id: message.guildId,
+        reply_to: replyTo,
+        ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
+      }
+    });
+  }
+  resolveProxyAgent() {
+    const proxy = this.config.proxy?.trim();
+    if (!proxy) {
+      return null;
+    }
+    try {
+      return new ProxyAgent(proxy);
+    } catch {
+      return null;
+    }
+  }
+  async resolveInboundAttachment(params) {
+    const { attachment, mediaDir, maxBytes, proxy } = params;
+    const id = attachment.id;
+    const name = attachment.name ?? "file";
+    const url = attachment.url;
+    const mimeType = attachment.contentType ?? guessMimeFromName(name) ?? void 0;
+    if (!url) {
+      return {
+        issue: {
+          id,
+          name,
+          code: "invalid_payload",
+          message: "attachment URL missing"
+        }
+      };
+    }
+    if (attachment.size && attachment.size > maxBytes) {
+      return {
+        attachment: {
+          id,
+          name,
+          url,
+          mimeType,
+          size: attachment.size,
+          source: "discord",
+          status: "remote-only",
+          errorCode: "too_large"
+        },
+        issue: {
+          id,
+          name,
+          url,
+          code: "too_large",
+          message: `attachment size ${attachment.size} exceeds ${maxBytes}`
+        }
+      };
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), MEDIA_FETCH_TIMEOUT_MS);
+    try {
+      const fetchInit = {
+        signal: controller.signal,
+        ...proxy ? { dispatcher: proxy } : {}
+      };
+      const res = await fetch2(url, fetchInit);
+      if (!res.ok) {
+        return {
+          attachment: {
+            id,
+            name,
+            url,
+            mimeType,
+            size: attachment.size,
+            source: "discord",
+            status: "remote-only",
+            errorCode: "http_error"
+          },
+          issue: {
+            id,
+            name,
+            url,
+            code: "http_error",
+            message: `HTTP ${res.status}`
+          }
+        };
+      }
+      const buffer = Buffer.from(await res.arrayBuffer());
+      if (buffer.length > maxBytes) {
+        return {
+          attachment: {
+            id,
+            name,
+            url,
+            mimeType,
+            size: buffer.length,
+            source: "discord",
+            status: "remote-only",
+            errorCode: "too_large"
+          },
+          issue: {
+            id,
+            name,
+            url,
+            code: "too_large",
+            message: `downloaded payload ${buffer.length} exceeds ${maxBytes}`
+          }
+        };
+      }
+      const filename = `${id}_${sanitizeAttachmentName(name)}`;
+      const filePath = join(mediaDir, filename);
+      writeFileSync(filePath, buffer);
+      return {
+        attachment: {
+          id,
+          name,
+          path: filePath,
+          url,
+          mimeType,
+          size: buffer.length,
+          source: "discord",
+          status: "ready"
+        }
+      };
+    } catch (err) {
+      return {
+        attachment: {
+          id,
+          name,
+          url,
+          mimeType,
+          size: attachment.size,
+          source: "discord",
+          status: "remote-only",
+          errorCode: "download_failed"
+        },
+        issue: {
+          id,
+          name,
+          url,
+          code: "download_failed",
+          message: String(err)
+        }
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  startTyping(channelId) {
+    this.stopTyping(channelId);
+    if (!this.client) {
+      return;
+    }
+    const channel = this.client.channels.cache.get(channelId);
+    if (!channel || !channel.isTextBased()) {
+      return;
+    }
+    const textChannel = channel;
+    const task = setInterval(() => {
+      void textChannel.sendTyping();
+    }, 8e3);
+    this.typingTasks.set(channelId, task);
+  }
+  stopTyping(channelId) {
+    const task = this.typingTasks.get(channelId);
+    if (task) {
+      clearInterval(task);
+      this.typingTasks.delete(channelId);
+    }
+  }
+};
+function sanitizeAttachmentName(name) {
+  return name.replace(/[\\/:*?"<>|]/g, "_");
+}
+function guessMimeFromName(name) {
+  const lower = name.toLowerCase();
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".bmp")) return "image/bmp";
+  if (lower.endsWith(".tif") || lower.endsWith(".tiff")) return "image/tiff";
+  return null;
+}
+function isImageAttachment(attachment) {
+  if (attachment.mimeType?.startsWith("image/")) {
+    return true;
+  }
+  return Boolean(attachment.name && guessMimeFromName(attachment.name));
+}
+function buildAttachmentSummary(attachments) {
+  const count = attachments.length;
+  if (count === 0) {
+    return "";
+  }
+  const allImages = attachments.every((entry) => isImageAttachment(entry));
+  if (allImages) {
+    return `<media:image> (${count} ${count === 1 ? "image" : "images"})`;
+  }
+  return `<media:document> (${count} ${count === 1 ? "file" : "files"})`;
+}
+
+// src/channels/email.ts
+import { ImapFlow } from "imapflow";
+import { simpleParser } from "mailparser";
+import nodemailer from "nodemailer";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var EmailChannel = class extends BaseChannel {
+  name = "email";
+  lastSubjectByChat = /* @__PURE__ */ new Map();
+  lastMessageIdByChat = /* @__PURE__ */ new Map();
+  processedUids = /* @__PURE__ */ new Set();
+  maxProcessedUids = 1e5;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.consentGranted) {
+      return;
+    }
+    if (!this.validateConfig()) {
+      return;
+    }
+    this.running = true;
+    const pollSeconds = Math.max(5, Number(this.config.pollIntervalSeconds ?? 30));
+    while (this.running) {
+      try {
+        const items = await this.fetchNewMessages();
+        for (const item of items) {
+          if (item.subject) {
+            this.lastSubjectByChat.set(item.sender, item.subject);
+          }
+          if (item.messageId) {
+            this.lastMessageIdByChat.set(item.sender, item.messageId);
+          }
+          await this.handleMessage({
+            senderId: item.sender,
+            chatId: item.sender,
+            content: item.content,
+            attachments: [],
+            metadata: item.metadata ?? {}
+          });
+        }
+      } catch {
+      }
+      await sleep(pollSeconds * 1e3);
+    }
+  }
+  async stop() {
+    this.running = false;
+  }
+  async send(msg) {
+    if (!this.config.consentGranted) {
+      return;
+    }
+    const forceSend = Boolean((msg.metadata ?? {}).force_send);
+    if (!this.config.autoReplyEnabled && !forceSend) {
+      return;
+    }
+    if (!this.config.smtpHost) {
+      return;
+    }
+    const toAddr = msg.chatId.trim();
+    if (!toAddr) {
+      return;
+    }
+    const baseSubject = this.lastSubjectByChat.get(toAddr) ?? APP_REPLY_SUBJECT;
+    const subject = msg.metadata?.subject?.trim() || this.replySubject(baseSubject);
+    const transporter = nodemailer.createTransport({
+      host: this.config.smtpHost,
+      port: this.config.smtpPort,
+      secure: this.config.smtpUseSsl,
+      auth: {
+        user: this.config.smtpUsername,
+        pass: this.config.smtpPassword
+      },
+      tls: this.config.smtpUseTls ? { rejectUnauthorized: false } : void 0
+    });
+    await transporter.sendMail({
+      from: this.config.fromAddress || this.config.smtpUsername || this.config.imapUsername,
+      to: toAddr,
+      subject,
+      text: msg.content ?? "",
+      inReplyTo: this.lastMessageIdByChat.get(toAddr) ?? void 0,
+      references: this.lastMessageIdByChat.get(toAddr) ?? void 0
+    });
+  }
+  validateConfig() {
+    const missing = [];
+    if (!this.config.imapHost) missing.push("imapHost");
+    if (!this.config.imapUsername) missing.push("imapUsername");
+    if (!this.config.imapPassword) missing.push("imapPassword");
+    if (!this.config.smtpHost) missing.push("smtpHost");
+    if (!this.config.smtpUsername) missing.push("smtpUsername");
+    if (!this.config.smtpPassword) missing.push("smtpPassword");
+    return missing.length === 0;
+  }
+  replySubject(subject) {
+    const prefix = this.config.subjectPrefix || "Re: ";
+    return subject.startsWith(prefix) ? subject : `${prefix}${subject}`;
+  }
+  async fetchNewMessages() {
+    const client = new ImapFlow({
+      host: this.config.imapHost,
+      port: this.config.imapPort,
+      secure: this.config.imapUseSsl,
+      auth: {
+        user: this.config.imapUsername,
+        pass: this.config.imapPassword
+      }
+    });
+    await client.connect();
+    const lock = await client.getMailboxLock(this.config.imapMailbox || "INBOX");
+    const items = [];
+    try {
+      const uids = await client.search({ seen: false });
+      if (!Array.isArray(uids)) {
+        return items;
+      }
+      for (const uid of uids) {
+        const key = String(uid);
+        if (this.processedUids.has(key)) {
+          continue;
+        }
+        const message = await client.fetchOne(uid, { uid: true, source: true, envelope: true });
+        if (!message || !message.source) {
+          continue;
+        }
+        const parsed = await simpleParser(message.source);
+        const sender = parsed.from?.value?.[0]?.address ?? "";
+        if (!sender) {
+          continue;
+        }
+        if (!this.isAllowed(sender)) {
+          continue;
+        }
+        const rawContent = parsed.text ?? parsed.html ?? "";
+        const content = typeof rawContent === "string" ? rawContent : "";
+        const subject = parsed.subject ?? "";
+        const messageId = parsed.messageId ?? "";
+        items.push({
+          sender,
+          subject,
+          content: content.slice(0, this.config.maxBodyChars),
+          messageId,
+          metadata: { subject }
+        });
+        if (this.config.markSeen) {
+          await client.messageFlagsAdd(uid, ["\\Seen"]);
+        }
+        this.processedUids.add(key);
+        if (this.processedUids.size > this.maxProcessedUids) {
+          const iterator = this.processedUids.values();
+          const oldest = iterator.next().value;
+          if (oldest) {
+            this.processedUids.delete(oldest);
+          }
+        }
+      }
+    } finally {
+      lock.release();
+      await client.logout();
+    }
+    return items;
+  }
+};
+
+// src/channels/feishu.ts
+import * as Lark from "@larksuiteoapi/node-sdk";
+var MSG_TYPE_MAP = {
+  image: "[image]",
+  audio: "[audio]",
+  file: "[file]",
+  sticker: "[sticker]"
+};
+var TABLE_RE = /((?:^[ \t]*\|.+\|[ \t]*\n)(?:^[ \t]*\|[-:\s|]+\|[ \t]*\n)(?:^[ \t]*\|.+\|[ \t]*\n?)+)/gm;
+var FeishuChannel = class extends BaseChannel {
+  name = "feishu";
+  client = null;
+  wsClient = null;
+  processedMessageIds = [];
+  processedSet = /* @__PURE__ */ new Set();
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.appId || !this.config.appSecret) {
+      throw new Error("Feishu appId/appSecret not configured");
+    }
+    this.running = true;
+    this.client = new Lark.Client({ appId: this.config.appId, appSecret: this.config.appSecret });
+    const dispatcher = new Lark.EventDispatcher({
+      encryptKey: this.config.encryptKey || void 0,
+      verificationToken: this.config.verificationToken || void 0
+    }).register({
+      "im.message.receive_v1": async (data) => {
+        await this.handleIncoming(data);
+      }
+    });
+    this.wsClient = new Lark.WSClient({
+      appId: this.config.appId,
+      appSecret: this.config.appSecret,
+      loggerLevel: Lark.LoggerLevel.info
+    });
+    this.wsClient.start({ eventDispatcher: dispatcher });
+  }
+  async stop() {
+    this.running = false;
+    if (this.wsClient) {
+      this.wsClient.close();
+      this.wsClient = null;
+    }
+  }
+  async send(msg) {
+    if (!this.client) {
+      return;
+    }
+    const receiveIdType = msg.chatId.startsWith("oc_") ? "chat_id" : "open_id";
+    const elements = buildCardElements(msg.content ?? "");
+    const card = {
+      config: { wide_screen_mode: true },
+      elements
+    };
+    const content = JSON.stringify(card);
+    await this.client.im.message.create({
+      params: { receive_id_type: receiveIdType },
+      data: {
+        receive_id: msg.chatId,
+        msg_type: "interactive",
+        content
+      }
+    });
+  }
+  async handleIncoming(data) {
+    const message = data.message ?? {};
+    const sender = message.sender ?? data.sender ?? {};
+    const senderIdObj = sender.sender_id ?? {};
+    const senderId = senderIdObj.open_id || senderIdObj.user_id || senderIdObj.union_id || sender.open_id || sender.user_id || "";
+    const senderType = sender.sender_type ?? sender.senderType;
+    if (senderType === "bot") {
+      return;
+    }
+    const chatId = message.chat_id ?? "";
+    const chatType = message.chat_type ?? "";
+    const msgType = message.msg_type ?? message.message_type ?? "";
+    const messageId = message.message_id ?? "";
+    if (!senderId || !chatId) {
+      return;
+    }
+    if (!this.isAllowed(String(senderId))) {
+      return;
+    }
+    if (messageId && this.isDuplicate(messageId)) {
+      return;
+    }
+    if (messageId) {
+      await this.addReaction(messageId, "THUMBSUP");
+    }
+    let content = "";
+    if (message.content) {
+      try {
+        const parsed = JSON.parse(String(message.content));
+        content = String(parsed.text ?? parsed.content ?? "");
+      } catch {
+        content = String(message.content);
+      }
+    }
+    if (!content && MSG_TYPE_MAP[msgType]) {
+      content = MSG_TYPE_MAP[msgType];
+    }
+    if (!content) {
+      return;
+    }
+    const replyTo = chatType === "group" ? chatId : String(senderId);
+    await this.handleMessage({
+      senderId: String(senderId),
+      chatId: replyTo,
+      content,
+      attachments: [],
+      metadata: {
+        message_id: messageId,
+        chat_type: chatType,
+        msg_type: msgType
+      }
+    });
+  }
+  isDuplicate(messageId) {
+    if (this.processedSet.has(messageId)) {
+      return true;
+    }
+    this.processedSet.add(messageId);
+    this.processedMessageIds.push(messageId);
+    if (this.processedMessageIds.length > 1e3) {
+      const removed = this.processedMessageIds.splice(0, 500);
+      for (const id of removed) {
+        this.processedSet.delete(id);
+      }
+    }
+    return false;
+  }
+  async addReaction(messageId, emojiType) {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.im.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: emojiType } }
+      });
+    } catch {
+    }
+  }
+};
+function buildCardElements(content) {
+  const elements = [];
+  let lastEnd = 0;
+  for (const match of content.matchAll(TABLE_RE)) {
+    const start = match.index ?? 0;
+    const tableText = match[1] ?? "";
+    const before = content.slice(lastEnd, start).trim();
+    if (before) {
+      elements.push({ tag: "markdown", content: before });
+    }
+    elements.push(parseMdTable(tableText) ?? { tag: "markdown", content: tableText });
+    lastEnd = start + tableText.length;
+  }
+  const remaining = content.slice(lastEnd).trim();
+  if (remaining) {
+    elements.push({ tag: "markdown", content: remaining });
+  }
+  if (!elements.length) {
+    elements.push({ tag: "markdown", content });
+  }
+  return elements;
+}
+function parseMdTable(tableText) {
+  const lines = tableText.trim().split("\n").map((line) => line.trim()).filter(Boolean);
+  if (lines.length < 3) {
+    return null;
+  }
+  const split = (line) => line.replace(/^\|+|\|+$/g, "").split("|").map((item) => item.trim());
+  const headers = split(lines[0]);
+  const rows = lines.slice(2).map(split);
+  const columns = headers.map((header, index) => ({
+    tag: "column",
+    name: `c${index}`,
+    display_name: header,
+    width: "auto"
+  }));
+  const tableRows = rows.map((row) => {
+    const values = {};
+    headers.forEach((_, index) => {
+      values[`c${index}`] = row[index] ?? "";
+    });
+    return values;
+  });
+  return {
+    tag: "table",
+    page_size: rows.length + 1,
+    columns,
+    rows: tableRows
+  };
+}
+
+// src/channels/mochat.ts
+import { io } from "socket.io-client";
+import { fetch as fetch3 } from "undici";
+import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2, existsSync, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+var MAX_SEEN_MESSAGE_IDS = 2e3;
+var CURSOR_SAVE_DEBOUNCE_MS = 500;
+var AsyncLock = class {
+  queue = Promise.resolve();
+  async run(task) {
+    const run = this.queue.then(task, task);
+    this.queue = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+};
+var MochatChannel = class extends BaseChannel {
+  name = "mochat";
+  socket = null;
+  wsConnected = false;
+  wsReady = false;
+  stateDir = join2(getDataPath(), "mochat");
+  cursorPath = join2(this.stateDir, "session_cursors.json");
+  sessionCursor = {};
+  cursorSaveTimer = null;
+  sessionSet = /* @__PURE__ */ new Set();
+  panelSet = /* @__PURE__ */ new Set();
+  autoDiscoverSessions = false;
+  autoDiscoverPanels = false;
+  coldSessions = /* @__PURE__ */ new Set();
+  sessionByConverse = /* @__PURE__ */ new Map();
+  seenSet = /* @__PURE__ */ new Map();
+  seenQueue = /* @__PURE__ */ new Map();
+  delayStates = /* @__PURE__ */ new Map();
+  fallbackMode = false;
+  sessionFallbackTasks = /* @__PURE__ */ new Map();
+  panelFallbackTasks = /* @__PURE__ */ new Map();
+  refreshTimer = null;
+  targetLocks = /* @__PURE__ */ new Map();
+  refreshInFlight = false;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    this.running = true;
+    if (!this.config.clawToken) {
+      throw new Error("Mochat clawToken not configured");
+    }
+    mkdirSync2(this.stateDir, { recursive: true });
+    await this.loadSessionCursors();
+    this.seedTargetsFromConfig();
+    await this.refreshTargets(false);
+    const socketReady = await this.startSocketClient();
+    if (!socketReady) {
+      await this.ensureFallbackWorkers();
+    }
+    const intervalMs = Math.max(1e3, this.config.refreshIntervalMs);
+    this.refreshTimer = setInterval(() => {
+      void this.refreshLoopTick();
+    }, intervalMs);
+  }
+  async stop() {
+    this.running = false;
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    await this.stopFallbackWorkers();
+    await this.cancelDelayTimers();
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    if (this.cursorSaveTimer) {
+      clearTimeout(this.cursorSaveTimer);
+      this.cursorSaveTimer = null;
+    }
+    await this.saveSessionCursors();
+    this.wsConnected = false;
+    this.wsReady = false;
+  }
+  async send(msg) {
+    if (!this.config.clawToken) {
+      return;
+    }
+    const parts = [];
+    if (msg.content && msg.content.trim()) {
+      parts.push(msg.content.trim());
+    }
+    if (msg.media?.length) {
+      for (const item of msg.media) {
+        if (typeof item === "string" && item.trim()) {
+          parts.push(item.trim());
+        }
+      }
+    }
+    const content = parts.join("\n").trim();
+    if (!content) {
+      return;
+    }
+    const target = resolveMochatTarget(msg.chatId);
+    if (!target.id) {
+      return;
+    }
+    const isPanel = (target.isPanel || this.panelSet.has(target.id)) && !target.id.startsWith("session_");
+    if (isPanel) {
+      await this.apiSend(
+        "/api/claw/groups/panels/send",
+        "panelId",
+        target.id,
+        content,
+        msg.replyTo,
+        readGroupId(msg.metadata ?? {})
+      );
+      return;
+    }
+    await this.apiSend("/api/claw/sessions/send", "sessionId", target.id, content, msg.replyTo);
+  }
+  seedTargetsFromConfig() {
+    const [sessions, autoSessions] = normalizeIdList(this.config.sessions);
+    const [panels, autoPanels] = normalizeIdList(this.config.panels);
+    this.autoDiscoverSessions = autoSessions;
+    this.autoDiscoverPanels = autoPanels;
+    sessions.forEach((sid) => {
+      this.sessionSet.add(sid);
+      if (!(sid in this.sessionCursor)) {
+        this.coldSessions.add(sid);
+      }
+    });
+    panels.forEach((pid) => {
+      this.panelSet.add(pid);
+    });
+  }
+  async startSocketClient() {
+    let parser = void 0;
+    if (!this.config.socketDisableMsgpack) {
+      try {
+        const mod = await import("socket.io-msgpack-parser");
+        parser = mod.default ?? mod;
+      } catch {
+        parser = void 0;
+      }
+    }
+    const socketUrl = (this.config.socketUrl || this.config.baseUrl).trim().replace(/\/$/, "");
+    const socketPath = (this.config.socketPath || "/socket.io").trim();
+    const reconnectionDelay = Math.max(100, this.config.socketReconnectDelayMs);
+    const reconnectionDelayMax = Math.max(100, this.config.socketMaxReconnectDelayMs);
+    const timeout = Math.max(1e3, this.config.socketConnectTimeoutMs);
+    const reconnectionAttempts = this.config.maxRetryAttempts > 0 ? this.config.maxRetryAttempts : Number.MAX_SAFE_INTEGER;
+    const socket = io(socketUrl, {
+      path: socketPath.startsWith("/") ? socketPath : `/${socketPath}`,
+      transports: ["websocket"],
+      auth: { token: this.config.clawToken },
+      reconnection: true,
+      reconnectionAttempts,
+      reconnectionDelay,
+      reconnectionDelayMax,
+      timeout,
+      parser
+    });
+    socket.on("connect", async () => {
+      this.wsConnected = true;
+      this.wsReady = false;
+      const subscribed = await this.subscribeAll();
+      this.wsReady = subscribed;
+      if (subscribed) {
+        await this.stopFallbackWorkers();
+      } else {
+        await this.ensureFallbackWorkers();
+      }
+    });
+    socket.on("disconnect", async () => {
+      if (!this.running) {
+        return;
+      }
+      this.wsConnected = false;
+      this.wsReady = false;
+      await this.ensureFallbackWorkers();
+    });
+    socket.on("connect_error", () => {
+      this.wsConnected = false;
+      this.wsReady = false;
+    });
+    socket.on("claw.session.events", async (payload) => {
+      await this.handleWatchPayload(payload, "session");
+    });
+    socket.on("claw.panel.events", async (payload) => {
+      await this.handleWatchPayload(payload, "panel");
+    });
+    const notifyHandler = (eventName) => async (payload) => {
+      if (eventName === "notify:chat.inbox.append") {
+        await this.handleNotifyInboxAppend(payload);
+        return;
+      }
+      if (eventName.startsWith("notify:chat.message.")) {
+        await this.handleNotifyChatMessage(payload);
+      }
+    };
+    [
+      "notify:chat.inbox.append",
+      "notify:chat.message.add",
+      "notify:chat.message.update",
+      "notify:chat.message.recall",
+      "notify:chat.message.delete"
+    ].forEach((eventName) => {
+      socket.on(eventName, notifyHandler(eventName));
+    });
+    this.socket = socket;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(false), timeout);
+      socket.once("connect", () => {
+        clearTimeout(timer);
+        resolve(true);
+      });
+      socket.once("connect_error", () => {
+        clearTimeout(timer);
+        resolve(false);
+      });
+    });
+  }
+  async subscribeAll() {
+    const sessions = Array.from(this.sessionSet).sort();
+    const panels = Array.from(this.panelSet).sort();
+    let ok = await this.subscribeSessions(sessions);
+    ok = await this.subscribePanels(panels) && ok;
+    if (this.autoDiscoverSessions || this.autoDiscoverPanels) {
+      await this.refreshTargets(true);
+    }
+    return ok;
+  }
+  async subscribeSessions(sessionIds) {
+    if (!sessionIds.length) {
+      return true;
+    }
+    for (const sid of sessionIds) {
+      if (!(sid in this.sessionCursor)) {
+        this.coldSessions.add(sid);
+      }
+    }
+    const ack = await this.socketCall("com.claw.im.subscribeSessions", {
+      sessionIds,
+      cursors: this.sessionCursor,
+      limit: this.config.watchLimit
+    });
+    if (!ack.result) {
+      return false;
+    }
+    const data = ack.data;
+    let items = [];
+    if (Array.isArray(data)) {
+      items = data.filter((item) => typeof item === "object" && item !== null);
+    } else if (data && typeof data === "object") {
+      const sessions = data.sessions;
+      if (Array.isArray(sessions)) {
+        items = sessions.filter((item) => typeof item === "object" && item !== null);
+      } else if (data.sessionId) {
+        items = [data];
+      }
+    }
+    for (const payload of items) {
+      await this.handleWatchPayload(payload, "session");
+    }
+    return true;
+  }
+  async subscribePanels(panelIds) {
+    if (!this.autoDiscoverPanels && !panelIds.length) {
+      return true;
+    }
+    const ack = await this.socketCall("com.claw.im.subscribePanels", { panelIds });
+    if (!ack.result) {
+      return false;
+    }
+    return true;
+  }
+  async socketCall(eventName, payload) {
+    if (!this.socket) {
+      return { result: false, message: "socket not connected" };
+    }
+    return new Promise((resolve) => {
+      this.socket?.timeout(1e4).emit(eventName, payload, (err, response) => {
+        if (err) {
+          resolve({ result: false, message: String(err) });
+          return;
+        }
+        if (response && typeof response === "object") {
+          resolve(response);
+          return;
+        }
+        resolve({ result: true, data: response });
+      });
+    });
+  }
+  async refreshLoopTick() {
+    if (!this.running || this.refreshInFlight) {
+      return;
+    }
+    this.refreshInFlight = true;
+    try {
+      await this.refreshTargets(this.wsReady);
+      if (this.fallbackMode) {
+        await this.ensureFallbackWorkers();
+      }
+    } finally {
+      this.refreshInFlight = false;
+    }
+  }
+  async refreshTargets(subscribeNew) {
+    if (this.autoDiscoverSessions) {
+      await this.refreshSessionsDirectory(subscribeNew);
+    }
+    if (this.autoDiscoverPanels) {
+      await this.refreshPanels(subscribeNew);
+    }
+  }
+  async refreshSessionsDirectory(subscribeNew) {
+    let response;
+    try {
+      response = await this.postJson("/api/claw/sessions/list", {});
+    } catch {
+      return;
+    }
+    const sessions = response.sessions;
+    if (!Array.isArray(sessions)) {
+      return;
+    }
+    const newIds = [];
+    for (const session of sessions) {
+      const sid = strField(session, "sessionId");
+      if (!sid) {
+        continue;
+      }
+      if (!this.sessionSet.has(sid)) {
+        this.sessionSet.add(sid);
+        newIds.push(sid);
+        if (!(sid in this.sessionCursor)) {
+          this.coldSessions.add(sid);
+        }
+      }
+      const converseId = strField(session, "converseId");
+      if (converseId) {
+        this.sessionByConverse.set(converseId, sid);
+      }
+    }
+    if (!newIds.length) {
+      return;
+    }
+    if (this.wsReady && subscribeNew) {
+      await this.subscribeSessions(newIds);
+    }
+    if (this.fallbackMode) {
+      await this.ensureFallbackWorkers();
+    }
+  }
+  async refreshPanels(subscribeNew) {
+    let response;
+    try {
+      response = await this.postJson("/api/claw/groups/get", {});
+    } catch {
+      return;
+    }
+    const panels = response.panels;
+    if (!Array.isArray(panels)) {
+      return;
+    }
+    const newIds = [];
+    for (const panel of panels) {
+      const panelType = panel.type;
+      if (typeof panelType === "number" && panelType !== 0) {
+        continue;
+      }
+      const pid = strField(panel, "id", "_id");
+      if (pid && !this.panelSet.has(pid)) {
+        this.panelSet.add(pid);
+        newIds.push(pid);
+      }
+    }
+    if (!newIds.length) {
+      return;
+    }
+    if (this.wsReady && subscribeNew) {
+      await this.subscribePanels(newIds);
+    }
+    if (this.fallbackMode) {
+      await this.ensureFallbackWorkers();
+    }
+  }
+  async ensureFallbackWorkers() {
+    if (!this.running) {
+      return;
+    }
+    this.fallbackMode = true;
+    for (const sid of this.sessionSet) {
+      if (this.sessionFallbackTasks.has(sid)) {
+        continue;
+      }
+      const task = this.sessionWatchWorker(sid).finally(() => {
+        if (this.sessionFallbackTasks.get(sid) === task) {
+          this.sessionFallbackTasks.delete(sid);
+        }
+      });
+      this.sessionFallbackTasks.set(sid, task);
+    }
+    for (const pid of this.panelSet) {
+      if (this.panelFallbackTasks.has(pid)) {
+        continue;
+      }
+      const task = this.panelPollWorker(pid).finally(() => {
+        if (this.panelFallbackTasks.get(pid) === task) {
+          this.panelFallbackTasks.delete(pid);
+        }
+      });
+      this.panelFallbackTasks.set(pid, task);
+    }
+  }
+  async stopFallbackWorkers() {
+    this.fallbackMode = false;
+    const tasks = [...this.sessionFallbackTasks.values(), ...this.panelFallbackTasks.values()];
+    this.sessionFallbackTasks.clear();
+    this.panelFallbackTasks.clear();
+    await Promise.allSettled(tasks);
+  }
+  async sessionWatchWorker(sessionId) {
+    while (this.running && this.fallbackMode) {
+      try {
+        const payload = await this.postJson("/api/claw/sessions/watch", {
+          sessionId,
+          cursor: this.sessionCursor[sessionId] ?? 0,
+          timeoutMs: this.config.watchTimeoutMs,
+          limit: this.config.watchLimit
+        });
+        await this.handleWatchPayload(payload, "session");
+      } catch {
+        await sleep2(Math.max(100, this.config.retryDelayMs));
+      }
+    }
+  }
+  async panelPollWorker(panelId) {
+    const sleepMs = Math.max(1e3, this.config.refreshIntervalMs);
+    while (this.running && this.fallbackMode) {
+      try {
+        const payload = await this.postJson("/api/claw/groups/panels/messages", {
+          panelId,
+          limit: Math.min(100, Math.max(1, this.config.watchLimit))
+        });
+        const messages = payload.messages;
+        if (Array.isArray(messages)) {
+          for (const msg of [...messages].reverse()) {
+            const event = makeSyntheticEvent({
+              messageId: String(msg.messageId ?? ""),
+              author: String(msg.author ?? ""),
+              content: msg.content,
+              meta: msg.meta,
+              groupId: String(payload.groupId ?? ""),
+              converseId: panelId,
+              timestamp: msg.createdAt,
+              authorInfo: msg.authorInfo
+            });
+            await this.processInboundEvent(panelId, event, "panel");
+          }
+        }
+      } catch {
+        await sleep2(sleepMs);
+      }
+      await sleep2(sleepMs);
+    }
+  }
+  async handleWatchPayload(payload, targetKind) {
+    if (!payload || typeof payload !== "object") {
+      return;
+    }
+    const targetId = strField(payload, "sessionId");
+    if (!targetId) {
+      return;
+    }
+    const lockKey = `${targetKind}:${targetId}`;
+    const lock = this.targetLocks.get(lockKey) ?? new AsyncLock();
+    this.targetLocks.set(lockKey, lock);
+    await lock.run(async () => {
+      const previousCursor = this.sessionCursor[targetId] ?? 0;
+      const cursor = payload.cursor;
+      if (targetKind === "session" && typeof cursor === "number" && cursor >= 0) {
+        this.markSessionCursor(targetId, cursor);
+      }
+      const rawEvents = payload.events;
+      if (!Array.isArray(rawEvents)) {
+        return;
+      }
+      if (targetKind === "session" && this.coldSessions.has(targetId)) {
+        this.coldSessions.delete(targetId);
+        return;
+      }
+      for (const event of rawEvents) {
+        const seq = event.seq;
+        if (targetKind === "session" && typeof seq === "number" && seq > (this.sessionCursor[targetId] ?? previousCursor)) {
+          this.markSessionCursor(targetId, seq);
+        }
+        if (event.type === "message.add") {
+          await this.processInboundEvent(targetId, event, targetKind);
+        }
+      }
+    });
+  }
+  async processInboundEvent(targetId, event, targetKind) {
+    const payload = event.payload;
+    if (!payload) {
+      return;
+    }
+    const author = strField(payload, "author");
+    if (!author || this.config.agentUserId && author === this.config.agentUserId) {
+      return;
+    }
+    if (!this.isAllowed(author)) {
+      return;
+    }
+    const messageId = strField(payload, "messageId");
+    const seenKey = `${targetKind}:${targetId}`;
+    if (messageId && this.rememberMessageId(seenKey, messageId)) {
+      return;
+    }
+    const rawBody = normalizeMochatContent(payload.content) || "[empty message]";
+    const authorInfo = safeDict(payload.authorInfo);
+    const senderName = strField(authorInfo, "nickname", "email");
+    const senderUsername = strField(authorInfo, "agentId");
+    const groupId = strField(payload, "groupId");
+    const isGroup = Boolean(groupId);
+    const wasMentioned = resolveWasMentioned(payload, this.config.agentUserId);
+    const requireMention = targetKind === "panel" && isGroup && resolveRequireMention(this.config, targetId, groupId);
+    const useDelay = targetKind === "panel" && this.config.replyDelayMode === "non-mention";
+    if (requireMention && !wasMentioned && !useDelay) {
+      return;
+    }
+    const entry = {
+      rawBody,
+      author,
+      senderName,
+      senderUsername,
+      timestamp: parseTimestamp(event.timestamp),
+      messageId,
+      groupId
+    };
+    if (useDelay) {
+      const delayKey = seenKey;
+      if (wasMentioned) {
+        await this.flushDelayedEntries(delayKey, targetId, targetKind, true, entry);
+      } else {
+        await this.enqueueDelayedEntry(delayKey, targetId, targetKind, entry);
+      }
+      return;
+    }
+    await this.dispatchEntries(targetId, targetKind, [entry], wasMentioned);
+  }
+  rememberMessageId(key, messageId) {
+    const seenSet = this.seenSet.get(key) ?? /* @__PURE__ */ new Set();
+    const seenQueue = this.seenQueue.get(key) ?? [];
+    if (seenSet.has(messageId)) {
+      return true;
+    }
+    seenSet.add(messageId);
+    seenQueue.push(messageId);
+    while (seenQueue.length > MAX_SEEN_MESSAGE_IDS) {
+      const removed = seenQueue.shift();
+      if (removed) {
+        seenSet.delete(removed);
+      }
+    }
+    this.seenSet.set(key, seenSet);
+    this.seenQueue.set(key, seenQueue);
+    return false;
+  }
+  async enqueueDelayedEntry(key, targetId, targetKind, entry) {
+    const state = this.delayStates.get(key) ?? { entries: [], timer: null, lock: new AsyncLock() };
+    this.delayStates.set(key, state);
+    await state.lock.run(async () => {
+      state.entries.push(entry);
+      if (state.timer) {
+        clearTimeout(state.timer);
+      }
+      state.timer = setTimeout(() => {
+        void this.flushDelayedEntries(key, targetId, targetKind, false, null);
+      }, Math.max(0, this.config.replyDelayMs));
+    });
+  }
+  async flushDelayedEntries(key, targetId, targetKind, mentioned, entry) {
+    const state = this.delayStates.get(key) ?? { entries: [], timer: null, lock: new AsyncLock() };
+    this.delayStates.set(key, state);
+    let entries = [];
+    await state.lock.run(async () => {
+      if (entry) {
+        state.entries.push(entry);
+      }
+      if (state.timer) {
+        clearTimeout(state.timer);
+        state.timer = null;
+      }
+      entries = [...state.entries];
+      state.entries = [];
+    });
+    if (entries.length) {
+      await this.dispatchEntries(targetId, targetKind, entries, mentioned);
+    }
+  }
+  async dispatchEntries(targetId, targetKind, entries, wasMentioned) {
+    const last = entries[entries.length - 1];
+    const isGroup = Boolean(last.groupId);
+    const body = buildBufferedBody(entries, isGroup) || "[empty message]";
+    await this.handleMessage({
+      senderId: last.author,
+      chatId: targetId,
+      content: body,
+      attachments: [],
+      metadata: {
+        message_id: last.messageId,
+        timestamp: last.timestamp,
+        is_group: isGroup,
+        group_id: last.groupId,
+        sender_name: last.senderName,
+        sender_username: last.senderUsername,
+        target_kind: targetKind,
+        was_mentioned: wasMentioned,
+        buffered_count: entries.length
+      }
+    });
+  }
+  async cancelDelayTimers() {
+    for (const state of this.delayStates.values()) {
+      if (state.timer) {
+        clearTimeout(state.timer);
+      }
+    }
+    this.delayStates.clear();
+  }
+  async handleNotifyChatMessage(payload) {
+    if (!payload || typeof payload !== "object") {
+      return;
+    }
+    const data = payload;
+    const groupId = strField(data, "groupId");
+    const panelId = strField(data, "converseId", "panelId");
+    if (!groupId || !panelId) {
+      return;
+    }
+    if (this.panelSet.size && !this.panelSet.has(panelId)) {
+      return;
+    }
+    const event = makeSyntheticEvent({
+      messageId: String(data._id ?? data.messageId ?? ""),
+      author: String(data.author ?? ""),
+      content: data.content,
+      meta: data.meta,
+      groupId,
+      converseId: panelId,
+      timestamp: data.createdAt,
+      authorInfo: data.authorInfo
+    });
+    await this.processInboundEvent(panelId, event, "panel");
+  }
+  async handleNotifyInboxAppend(payload) {
+    if (!payload || typeof payload !== "object") {
+      return;
+    }
+    const data = payload;
+    if (data.type !== "message") {
+      return;
+    }
+    const detail = data.payload;
+    if (!detail || typeof detail !== "object") {
+      return;
+    }
+    if (strField(detail, "groupId")) {
+      return;
+    }
+    const converseId = strField(detail, "converseId");
+    if (!converseId) {
+      return;
+    }
+    let sessionId = this.sessionByConverse.get(converseId);
+    if (!sessionId) {
+      await this.refreshSessionsDirectory(this.wsReady);
+      sessionId = this.sessionByConverse.get(converseId);
+    }
+    if (!sessionId) {
+      return;
+    }
+    const event = makeSyntheticEvent({
+      messageId: String(detail.messageId ?? data._id ?? ""),
+      author: String(detail.messageAuthor ?? ""),
+      content: String(detail.messagePlainContent ?? detail.messageSnippet ?? ""),
+      meta: { source: "notify:chat.inbox.append", converseId },
+      groupId: "",
+      converseId,
+      timestamp: data.createdAt
+    });
+    await this.processInboundEvent(sessionId, event, "session");
+  }
+  markSessionCursor(sessionId, cursor) {
+    if (cursor < 0) {
+      return;
+    }
+    const current = this.sessionCursor[sessionId] ?? 0;
+    if (cursor < current) {
+      return;
+    }
+    this.sessionCursor[sessionId] = cursor;
+    if (!this.cursorSaveTimer) {
+      this.cursorSaveTimer = setTimeout(() => {
+        this.cursorSaveTimer = null;
+        void this.saveSessionCursors();
+      }, CURSOR_SAVE_DEBOUNCE_MS);
+    }
+  }
+  async loadSessionCursors() {
+    if (!existsSync(this.cursorPath)) {
+      return;
+    }
+    try {
+      const raw = readFileSync(this.cursorPath, "utf-8");
+      const data = JSON.parse(raw);
+      const cursors = data.cursors;
+      if (cursors && typeof cursors === "object") {
+        for (const [sid, value] of Object.entries(cursors)) {
+          if (typeof value === "number" && value >= 0) {
+            this.sessionCursor[sid] = value;
+          }
+        }
+      }
+    } catch {
+      return;
+    }
+  }
+  async saveSessionCursors() {
+    try {
+      mkdirSync2(this.stateDir, { recursive: true });
+      const payload = {
+        schemaVersion: 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cursors: this.sessionCursor
+      };
+      writeFileSync2(this.cursorPath, JSON.stringify(payload, null, 2) + "\n");
+    } catch {
+      return;
+    }
+  }
+  async postJson(path, payload) {
+    const url = `${this.config.baseUrl.trim().replace(/\/$/, "")}${path}`;
+    const response = await fetch3(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "X-Claw-Token": this.config.clawToken
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Mochat HTTP ${response.status}`);
+    }
+    let parsed;
+    try {
+      parsed = await response.json();
+    } catch {
+      parsed = await response.text();
+    }
+    if (parsed && typeof parsed === "object" && parsed.code !== void 0) {
+      const data = parsed;
+      if (typeof data.code === "number" && data.code !== 200) {
+        throw new Error(String(data.message ?? data.name ?? "request failed"));
+      }
+      if (data.data && typeof data.data === "object") {
+        return data.data;
+      }
+      return {};
+    }
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+    return {};
+  }
+  async apiSend(path, idKey, idValue, content, replyTo, groupId) {
+    const body = { [idKey]: idValue, content };
+    if (replyTo) {
+      body.replyTo = replyTo;
+    }
+    if (groupId) {
+      body.groupId = groupId;
+    }
+    await this.postJson(path, body);
+  }
+};
+function normalizeIdList(values) {
+  const cleaned = values.map((value) => String(value).trim()).filter(Boolean);
+  const unique = Array.from(new Set(cleaned.filter((value) => value !== "*"))).sort();
+  return [unique, cleaned.includes("*")];
+}
+function safeDict(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function strField(src, ...keys) {
+  for (const key of keys) {
+    const value = src[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+function makeSyntheticEvent(params) {
+  const payload = {
+    messageId: params.messageId,
+    author: params.author,
+    content: params.content,
+    meta: safeDict(params.meta),
+    groupId: params.groupId,
+    converseId: params.converseId
+  };
+  if (params.authorInfo) {
+    payload.authorInfo = safeDict(params.authorInfo);
+  }
+  return {
+    type: "message.add",
+    timestamp: params.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+}
+function normalizeMochatContent(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (content === null || content === void 0) {
+    return "";
+  }
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+function resolveMochatTarget(raw) {
+  const trimmed = (raw || "").trim();
+  if (!trimmed) {
+    return { id: "", isPanel: false };
+  }
+  const lowered = trimmed.toLowerCase();
+  let cleaned = trimmed;
+  let forcedPanel = false;
+  for (const prefix of ["mochat:", "group:", "channel:", "panel:"]) {
+    if (lowered.startsWith(prefix)) {
+      cleaned = trimmed.slice(prefix.length).trim();
+      forcedPanel = prefix !== "mochat:";
+      break;
+    }
+  }
+  if (!cleaned) {
+    return { id: "", isPanel: false };
+  }
+  return { id: cleaned, isPanel: forcedPanel || !cleaned.startsWith("session_") };
+}
+function extractMentionIds(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const ids = [];
+  for (const item of value) {
+    if (typeof item === "string" && item.trim()) {
+      ids.push(item.trim());
+    } else if (item && typeof item === "object") {
+      const obj = item;
+      for (const key of ["id", "userId", "_id"]) {
+        const candidate = obj[key];
+        if (typeof candidate === "string" && candidate.trim()) {
+          ids.push(candidate.trim());
+          break;
+        }
+      }
+    }
+  }
+  return ids;
+}
+function resolveWasMentioned(payload, agentUserId) {
+  const meta = payload.meta;
+  if (meta) {
+    if (meta.mentioned === true || meta.wasMentioned === true) {
+      return true;
+    }
+    for (const field of ["mentions", "mentionIds", "mentionedUserIds", "mentionedUsers"]) {
+      if (agentUserId && extractMentionIds(meta[field]).includes(agentUserId)) {
+        return true;
+      }
+    }
+  }
+  if (!agentUserId) {
+    return false;
+  }
+  const content = payload.content;
+  if (typeof content !== "string" || !content) {
+    return false;
+  }
+  return content.includes(`<@${agentUserId}>`) || content.includes(`@${agentUserId}`);
+}
+function resolveRequireMention(config, sessionId, groupId) {
+  const groups = config.groups ?? {};
+  for (const key of [groupId, sessionId, "*"]) {
+    if (key && groups[key]) {
+      return Boolean(groups[key].requireMention);
+    }
+  }
+  return Boolean(config.mention.requireInGroups);
+}
+function buildBufferedBody(entries, isGroup) {
+  if (!entries.length) {
+    return "";
+  }
+  if (entries.length === 1) {
+    return entries[0].rawBody;
+  }
+  const lines = [];
+  for (const entry of entries) {
+    if (!entry.rawBody) {
+      continue;
+    }
+    if (isGroup) {
+      const label = entry.senderName.trim() || entry.senderUsername.trim() || entry.author;
+      if (label) {
+        lines.push(`${label}: ${entry.rawBody}`);
+        continue;
+      }
+    }
+    lines.push(entry.rawBody);
+  }
+  return lines.join("\n").trim();
+}
+function parseTimestamp(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function readGroupId(metadata) {
+  const value = metadata.group_id ?? metadata.groupId;
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  return null;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/channels/qq.ts
+import {
+  Bot,
+  ReceiverMode,
+  segment
+} from "qq-official-bot";
+var QQChannel = class extends BaseChannel {
+  name = "qq";
+  bot = null;
+  processedIds = [];
+  processedSet = /* @__PURE__ */ new Set();
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    this.running = true;
+    if (!this.config.appId || !this.config.secret) {
+      throw new Error("QQ appId/appSecret not configured");
+    }
+    this.bot = new Bot({
+      appid: this.config.appId,
+      secret: this.config.secret,
+      mode: ReceiverMode.WEBSOCKET,
+      intents: ["C2C_MESSAGE_CREATE", "GROUP_AT_MESSAGE_CREATE"],
+      removeAt: true,
+      logLevel: "info"
+    });
+    this.bot.on("message.private", async (event) => {
+      await this.handleIncoming(event);
+    });
+    this.bot.on("message.group", async (event) => {
+      await this.handleIncoming(event);
+    });
+    await this.bot.start();
+    console.log("QQ bot connected");
+  }
+  async stop() {
+    this.running = false;
+    if (this.bot) {
+      this.bot.removeAllListeners("message.private");
+      this.bot.removeAllListeners("message.group");
+      await this.bot.stop();
+      this.bot = null;
+    }
+  }
+  async send(msg) {
+    if (!this.bot) {
+      return;
+    }
+    const qqMeta = msg.metadata?.qq ?? {};
+    const messageType = qqMeta.messageType ?? "private";
+    const metadataMessageId = msg.metadata?.message_id ?? null;
+    const sourceId = msg.replyTo ?? metadataMessageId ?? void 0;
+    const source = sourceId ? { id: sourceId } : void 0;
+    const payload = this.config.markdownSupport ? segment.markdown(msg.content ?? "") : msg.content ?? "";
+    if (messageType === "group") {
+      const groupId = qqMeta.groupId ?? msg.chatId;
+      await this.sendWithTokenRetry(() => this.bot?.sendGroupMessage(groupId, payload, source));
+      return;
+    }
+    if (messageType === "direct") {
+      const guildId = qqMeta.guildId ?? msg.chatId;
+      await this.sendWithTokenRetry(() => this.bot?.sendDirectMessage(guildId, payload, source));
+      return;
+    }
+    if (messageType === "guild") {
+      const channelId = qqMeta.channelId ?? msg.chatId;
+      await this.sendWithTokenRetry(() => this.bot?.sendGuildMessage(channelId, payload, source));
+      return;
+    }
+    const userId = qqMeta.userId ?? msg.chatId;
+    await this.sendWithTokenRetry(() => this.bot?.sendPrivateMessage(userId, payload, source));
+  }
+  async handleIncoming(event) {
+    const messageId = event.message_id || event.id || "";
+    if (messageId && this.isDuplicate(messageId)) {
+      return;
+    }
+    if (event.user_id === event.self_id) {
+      return;
+    }
+    const rawEvent = event;
+    const senderId = event.user_id || rawEvent.sender?.member_openid || rawEvent.sender?.user_openid || rawEvent.sender?.user_id || "";
+    if (!senderId) {
+      return;
+    }
+    const content = event.raw_message?.trim() ?? "";
+    const safeContent = content || "[empty message]";
+    let chatId = senderId;
+    let messageType = "private";
+    const qqMeta = {};
+    if (event.message_type === "group") {
+      messageType = "group";
+      const groupId = event.group_id || rawEvent.group_openid || "";
+      chatId = groupId;
+      qqMeta.groupId = groupId;
+      qqMeta.userId = senderId;
+    } else if (event.message_type === "guild") {
+      messageType = "guild";
+      chatId = event.channel_id ?? "";
+      qqMeta.guildId = event.guild_id;
+      qqMeta.channelId = event.channel_id;
+      qqMeta.userId = senderId;
+    } else if (event.sub_type === "direct") {
+      messageType = "direct";
+      chatId = event.guild_id ?? "";
+      qqMeta.guildId = event.guild_id;
+      qqMeta.userId = senderId;
+    } else {
+      qqMeta.userId = senderId;
+    }
+    qqMeta.messageType = messageType;
+    if (!chatId) {
+      return;
+    }
+    if (!this.isAllowed(senderId)) {
+      return;
+    }
+    await this.handleMessage({
+      senderId,
+      chatId,
+      content: safeContent,
+      attachments: [],
+      metadata: {
+        message_id: messageId,
+        qq: qqMeta
+      }
+    });
+  }
+  isDuplicate(messageId) {
+    if (this.processedSet.has(messageId)) {
+      return true;
+    }
+    this.processedSet.add(messageId);
+    this.processedIds.push(messageId);
+    if (this.processedIds.length > 1e3) {
+      const removed = this.processedIds.splice(0, 500);
+      for (const id of removed) {
+        this.processedSet.delete(id);
+      }
+    }
+    return false;
+  }
+  async sendWithTokenRetry(send) {
+    try {
+      await send();
+    } catch (error) {
+      if (!this.isTokenExpiredError(error) || !this.bot) {
+        throw error;
+      }
+      await this.bot.sessionManager.getAccessToken();
+      await send();
+    }
+  }
+  isTokenExpiredError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("code(11244)") || message.toLowerCase().includes("token not exist or expire");
+  }
+};
+
+// src/channels/slack.ts
+import { WebClient } from "@slack/web-api";
+import { SocketModeClient } from "@slack/socket-mode";
+var SlackChannel = class extends BaseChannel {
+  name = "slack";
+  webClient = null;
+  socketClient = null;
+  botUserId = null;
+  botId = null;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.botToken || !this.config.appToken) {
+      throw new Error("Slack bot/app token not configured");
+    }
+    if (this.config.mode !== "socket") {
+      throw new Error(`Unsupported Slack mode: ${this.config.mode}`);
+    }
+    this.running = true;
+    this.webClient = new WebClient(this.config.botToken);
+    this.socketClient = new SocketModeClient({
+      appToken: this.config.appToken
+    });
+    this.socketClient.on("events_api", async ({ body, ack }) => {
+      await ack();
+      await this.handleEvent(body?.event);
+    });
+    try {
+      const auth = await this.webClient.auth.test();
+      this.botUserId = auth.user_id ?? null;
+      this.botId = auth.bot_id ?? null;
+    } catch {
+      this.botUserId = null;
+      this.botId = null;
+    }
+    await this.socketClient.start();
+  }
+  async stop() {
+    this.running = false;
+    if (this.socketClient) {
+      await this.socketClient.disconnect();
+      this.socketClient = null;
+    }
+    this.botUserId = null;
+    this.botId = null;
+  }
+  async send(msg) {
+    if (!this.webClient) {
+      return;
+    }
+    const slackMeta = msg.metadata?.slack ?? {};
+    const threadTs = slackMeta.thread_ts;
+    const channelType = slackMeta.channel_type;
+    const useThread = Boolean(threadTs && channelType !== "im");
+    await this.webClient.chat.postMessage({
+      channel: msg.chatId,
+      text: msg.content ?? "",
+      thread_ts: useThread ? threadTs : void 0
+    });
+  }
+  async handleEvent(event) {
+    if (!event) {
+      return;
+    }
+    const eventType = event.type;
+    if (eventType !== "message" && eventType !== "app_mention") {
+      return;
+    }
+    const subtype = event.subtype;
+    const botId = event.bot_id;
+    const isBotMessage = subtype === "bot_message" || Boolean(botId);
+    if (subtype && subtype !== "bot_message") {
+      return;
+    }
+    if (isBotMessage && !this.config.allowBots) {
+      return;
+    }
+    const senderId = event.user ?? (isBotMessage ? botId : void 0);
+    const chatId = event.channel;
+    const channelType = event.channel_type ?? "";
+    const text = event.text ?? "";
+    if (!senderId || !chatId) {
+      return;
+    }
+    if (this.botUserId && event.user === this.botUserId) {
+      return;
+    }
+    if (this.botId && botId && botId === this.botId) {
+      return;
+    }
+    if (eventType === "message" && !isBotMessage && this.botUserId && text.includes(`<@${this.botUserId}>`)) {
+      return;
+    }
+    if (!this.isAllowedInSlack(senderId, chatId, channelType)) {
+      return;
+    }
+    if (channelType !== "im" && !this.shouldRespondInChannel(eventType, text, chatId)) {
+      return;
+    }
+    const cleanText = this.stripBotMention(text);
+    const threadTs = event.thread_ts ?? event.ts;
+    try {
+      if (this.webClient && event.ts) {
+        await this.webClient.reactions.add({
+          channel: chatId,
+          name: "eyes",
+          timestamp: event.ts
+        });
+      }
+    } catch {
+    }
+    await this.handleMessage({
+      senderId,
+      chatId,
+      content: cleanText,
+      attachments: [],
+      metadata: {
+        slack: {
+          event,
+          thread_ts: threadTs,
+          channel_type: channelType
+        }
+      }
+    });
+  }
+  isAllowedInSlack(senderId, chatId, channelType) {
+    if (channelType === "im") {
+      if (!this.config.dm.enabled) {
+        return false;
+      }
+      if (this.config.dm.policy === "allowlist") {
+        return this.config.dm.allowFrom.includes(senderId);
+      }
+      return true;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      return this.config.groupAllowFrom.includes(chatId);
+    }
+    return true;
+  }
+  shouldRespondInChannel(eventType, text, chatId) {
+    if (this.config.groupPolicy === "open") {
+      return true;
+    }
+    if (this.config.groupPolicy === "mention") {
+      if (eventType === "app_mention") {
+        return true;
+      }
+      return this.botUserId ? text.includes(`<@${this.botUserId}>`) : false;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      return this.config.groupAllowFrom.includes(chatId);
+    }
+    return false;
+  }
+  stripBotMention(text) {
+    if (!text || !this.botUserId) {
+      return text;
+    }
+    const pattern = new RegExp(`<@${this.botUserId}>\\s*`, "g");
+    return text.replace(pattern, "").trim();
+  }
+};
+
+// src/channels/telegram.ts
+import TelegramBot from "node-telegram-bot-api";
+
+// src/providers/transcription.ts
+import { createReadStream, existsSync as existsSync2 } from "fs";
+import { basename } from "path";
+import { FormData, fetch as fetch4 } from "undici";
+var GroqTranscriptionProvider = class {
+  apiKey;
+  apiUrl = "https://api.groq.com/openai/v1/audio/transcriptions";
+  constructor(apiKey) {
+    this.apiKey = apiKey ?? process.env.GROQ_API_KEY ?? null;
+  }
+  async transcribe(filePath) {
+    if (!this.apiKey) {
+      return "";
+    }
+    if (!existsSync2(filePath)) {
+      return "";
+    }
+    const form = new FormData();
+    form.append("file", createReadStream(filePath), basename(filePath));
+    form.append("model", "whisper-large-v3");
+    const response = await fetch4(this.apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: form
+    });
+    if (!response.ok) {
+      return "";
+    }
+    const data = await response.json();
+    return data.text ?? "";
+  }
+};
+
+// src/channels/telegram.ts
+import { join as join3 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+var BOT_COMMANDS = [
+  { command: "start", description: "Start the bot" },
+  { command: "reset", description: "Reset conversation history" },
+  { command: "help", description: "Show available commands" }
+];
+var TelegramChannel = class extends BaseChannel {
+  constructor(config, bus, groqApiKey, sessionManager) {
+    super(config, bus);
+    this.sessionManager = sessionManager;
+    this.transcriber = new GroqTranscriptionProvider(groqApiKey ?? null);
+  }
+  name = "telegram";
+  bot = null;
+  typingTasks = /* @__PURE__ */ new Map();
+  transcriber;
+  async start() {
+    if (!this.config.token) {
+      throw new Error("Telegram bot token not configured");
+    }
+    this.running = true;
+    const options = { polling: true };
+    if (this.config.proxy) {
+      options.request = { proxy: this.config.proxy };
+    }
+    this.bot = new TelegramBot(this.config.token, options);
+    this.bot.onText(/^\/start$/, async (msg) => {
+      await this.bot?.sendMessage(
+        msg.chat.id,
+        `\u{1F44B} Hi ${msg.from?.first_name ?? ""}! I'm ${APP_NAME}.
+
+Send me a message and I'll respond!
+Type /help to see available commands.`
+      );
+    });
+    this.bot.onText(/^\/help$/, async (msg) => {
+      const helpText = `\u{1F916} <b>${APP_NAME} commands</b>
+
+/start \u2014 Start the bot
+/reset \u2014 Reset conversation history
+/help \u2014 Show this help message
+
+Just send me a text message to chat!`;
+      await this.bot?.sendMessage(msg.chat.id, helpText, { parse_mode: "HTML" });
+    });
+    this.bot.onText(/^\/reset$/, async (msg) => {
+      const chatId = String(msg.chat.id);
+      if (!this.sessionManager) {
+        await this.bot?.sendMessage(msg.chat.id, "\u26A0\uFE0F Session management is not available.");
+        return;
+      }
+      const sessionKey = `${this.name}:${chatId}`;
+      const session = this.sessionManager.getOrCreate(sessionKey);
+      const count = session.messages.length;
+      this.sessionManager.clear(session);
+      this.sessionManager.save(session);
+      await this.bot?.sendMessage(msg.chat.id, `\u{1F504} Conversation history cleared (${count} messages).`);
+    });
+    this.bot.on("message", async (msg) => {
+      if (!msg.text && !msg.caption && !msg.photo && !msg.voice && !msg.audio && !msg.document) {
+        return;
+      }
+      if (msg.text?.startsWith("/")) {
+        return;
+      }
+      await this.handleIncoming(msg);
+    });
+    this.bot.on("channel_post", async (msg) => {
+      if (!msg.text && !msg.caption && !msg.photo && !msg.voice && !msg.audio && !msg.document) {
+        return;
+      }
+      if (msg.text?.startsWith("/")) {
+        return;
+      }
+      await this.handleIncoming(msg);
+    });
+    await this.bot.setMyCommands(BOT_COMMANDS);
+  }
+  async stop() {
+    this.running = false;
+    for (const task of this.typingTasks.values()) {
+      clearInterval(task);
+    }
+    this.typingTasks.clear();
+    if (this.bot) {
+      await this.bot.stopPolling();
+      this.bot = null;
+    }
+  }
+  async send(msg) {
+    if (!this.bot) {
+      return;
+    }
+    this.stopTyping(msg.chatId);
+    const htmlContent = markdownToTelegramHtml(msg.content ?? "");
+    const silent = msg.metadata?.silent === true;
+    const replyTo = msg.replyTo ? Number(msg.replyTo) : void 0;
+    const options = {
+      parse_mode: "HTML",
+      ...replyTo ? { reply_to_message_id: replyTo } : {},
+      ...silent ? { disable_notification: true } : {}
+    };
+    try {
+      await this.bot.sendMessage(Number(msg.chatId), htmlContent, options);
+    } catch {
+      await this.bot.sendMessage(Number(msg.chatId), msg.content ?? "", {
+        ...replyTo ? { reply_to_message_id: replyTo } : {},
+        ...silent ? { disable_notification: true } : {}
+      });
+    }
+  }
+  async handleIncoming(message) {
+    if (!this.bot) {
+      return;
+    }
+    const sender = resolveSender(message);
+    if (!sender) {
+      return;
+    }
+    const chatId = String(message.chat.id);
+    let senderId = String(sender.id);
+    if (sender.username) {
+      senderId = `${senderId}|${sender.username}`;
+    }
+    const contentParts = [];
+    const attachments = [];
+    if (message.text) {
+      contentParts.push(message.text);
+    }
+    if (message.caption) {
+      contentParts.push(message.caption);
+    }
+    const { fileId, mediaType, mimeType } = resolveMedia(message);
+    if (fileId && mediaType) {
+      const mediaDir = join3(getDataPath(), "media");
+      mkdirSync3(mediaDir, { recursive: true });
+      const extension = getExtension(mediaType, mimeType);
+      const downloaded = await this.bot.downloadFile(fileId, mediaDir);
+      const finalPath = extension && !downloaded.endsWith(extension) ? `${downloaded}${extension}` : downloaded;
+      attachments.push({
+        id: fileId,
+        name: finalPath.split("/").pop(),
+        path: finalPath,
+        mimeType: mimeType ?? inferMediaMimeType(mediaType),
+        source: "telegram",
+        status: "ready"
+      });
+      if (mediaType === "voice" || mediaType === "audio") {
+        const transcription = await this.transcriber.transcribe(finalPath);
+        if (transcription) {
+          contentParts.push(`[transcription: ${transcription}]`);
+        } else {
+          contentParts.push(`[${mediaType}: ${finalPath}]`);
+        }
+      } else {
+        contentParts.push(`[${mediaType}: ${finalPath}]`);
+      }
+    }
+    const content = contentParts.length ? contentParts.join("\n") : "[empty message]";
+    this.startTyping(chatId);
+    await this.dispatchToBus(senderId, chatId, content, attachments, {
+      message_id: message.message_id,
+      user_id: sender.id,
+      username: sender.username,
+      first_name: sender.firstName,
+      sender_type: sender.type,
+      is_bot: sender.isBot,
+      is_group: message.chat.type !== "private"
+    });
+  }
+  async dispatchToBus(senderId, chatId, content, attachments, metadata) {
+    await this.handleMessage({ senderId, chatId, content, attachments, metadata });
+  }
+  startTyping(chatId) {
+    this.stopTyping(chatId);
+    if (!this.bot) {
+      return;
+    }
+    const task = setInterval(() => {
+      void this.bot?.sendChatAction(Number(chatId), "typing");
+    }, 4e3);
+    this.typingTasks.set(chatId, task);
+  }
+  stopTyping(chatId) {
+    const task = this.typingTasks.get(chatId);
+    if (task) {
+      clearInterval(task);
+      this.typingTasks.delete(chatId);
+    }
+  }
+};
+function resolveSender(message) {
+  if (message.from) {
+    return {
+      id: message.from.id,
+      username: message.from.username,
+      firstName: message.from.first_name,
+      isBot: Boolean(message.from.is_bot),
+      type: "user"
+    };
+  }
+  if (message.sender_chat) {
+    return {
+      id: message.sender_chat.id,
+      username: message.sender_chat.username,
+      firstName: message.sender_chat.title,
+      isBot: true,
+      type: "sender_chat"
+    };
+  }
+  return null;
+}
+function resolveMedia(message) {
+  if (message.photo?.length) {
+    const photo = message.photo[message.photo.length - 1];
+    return { fileId: photo.file_id, mediaType: "image", mimeType: "image/jpeg" };
+  }
+  if (message.voice) {
+    return { fileId: message.voice.file_id, mediaType: "voice", mimeType: message.voice.mime_type };
+  }
+  if (message.audio) {
+    return { fileId: message.audio.file_id, mediaType: "audio", mimeType: message.audio.mime_type };
+  }
+  if (message.document) {
+    return { fileId: message.document.file_id, mediaType: "file", mimeType: message.document.mime_type };
+  }
+  return {};
+}
+function getExtension(mediaType, mimeType) {
+  const map = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "audio/ogg": ".ogg",
+    "audio/mpeg": ".mp3",
+    "audio/mp4": ".m4a"
+  };
+  if (mimeType && map[mimeType]) {
+    return map[mimeType];
+  }
+  const fallback = {
+    image: ".jpg",
+    voice: ".ogg",
+    audio: ".mp3",
+    file: ""
+  };
+  return fallback[mediaType] ?? "";
+}
+function inferMediaMimeType(mediaType) {
+  if (!mediaType) {
+    return void 0;
+  }
+  if (mediaType === "image") {
+    return "image/jpeg";
+  }
+  if (mediaType === "voice") {
+    return "audio/ogg";
+  }
+  if (mediaType === "audio") {
+    return "audio/mpeg";
+  }
+  return void 0;
+}
+function markdownToTelegramHtml(text) {
+  if (!text) {
+    return "";
+  }
+  const codeBlocks = [];
+  text = text.replace(/```[\w]*\n?([\s\S]*?)```/g, (_m, code) => {
+    codeBlocks.push(code);
+    return `\0CB${codeBlocks.length - 1}\0`;
+  });
+  const inlineCodes = [];
+  text = text.replace(/`([^`]+)`/g, (_m, code) => {
+    inlineCodes.push(code);
+    return `\0IC${inlineCodes.length - 1}\0`;
+  });
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+  text = text.replace(/^>\s*(.*)$/gm, "$1");
+  text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  text = text.replace(/__(.+?)__/g, "<b>$1</b>");
+  text = text.replace(/(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
+  text = text.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  text = text.replace(/^[-*]\s+/gm, "\u2022 ");
+  inlineCodes.forEach((code, i) => {
+    const escaped = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    text = text.replace(`\0IC${i}\0`, `<code>${escaped}</code>`);
+  });
+  codeBlocks.forEach((code, i) => {
+    const escaped = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    text = text.replace(`\0CB${i}\0`, `<pre><code>${escaped}</code></pre>`);
+  });
+  return text;
+}
+
+// src/channels/whatsapp.ts
+import WebSocket from "ws";
+var WhatsAppChannel = class extends BaseChannel {
+  name = "whatsapp";
+  ws = null;
+  connected = false;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    this.running = true;
+    const bridgeUrl = this.config.bridgeUrl;
+    while (this.running) {
+      try {
+        await new Promise((resolve, reject) => {
+          const ws = new WebSocket(bridgeUrl);
+          this.ws = ws;
+          ws.on("open", () => {
+            this.connected = true;
+          });
+          ws.on("message", (data) => {
+            const payload = data.toString();
+            void this.handleBridgeMessage(payload);
+          });
+          ws.on("close", () => {
+            this.connected = false;
+            this.ws = null;
+            resolve();
+          });
+          ws.on("error", (_err) => {
+            this.connected = false;
+            this.ws = null;
+            reject(_err);
+          });
+        });
+      } catch {
+        if (!this.running) {
+          break;
+        }
+        await sleep3(5e3);
+      }
+    }
+  }
+  async stop() {
+    this.running = false;
+    this.connected = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  async send(msg) {
+    if (!this.ws || !this.connected) {
+      return;
+    }
+    const payload = {
+      type: "send",
+      to: msg.chatId,
+      text: msg.content
+    };
+    this.ws.send(JSON.stringify(payload));
+  }
+  async handleBridgeMessage(raw) {
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const msgType = data.type;
+    if (msgType === "message") {
+      const pn = data.pn ?? "";
+      const sender = data.sender ?? "";
+      let content = data.content ?? "";
+      const userId = pn || sender;
+      const senderId = userId.includes("@") ? userId.split("@")[0] : userId;
+      if (content === "[Voice Message]") {
+        content = "[Voice Message: Transcription not available for WhatsApp yet]";
+      }
+      await this.handleMessage({
+        senderId,
+        chatId: sender || userId,
+        content,
+        attachments: [],
+        metadata: {
+          message_id: data.id,
+          timestamp: data.timestamp,
+          is_group: Boolean(data.isGroup)
+        }
+      });
+      return;
+    }
+    if (msgType === "status") {
+      const status = data.status;
+      if (status === "connected") {
+        this.connected = true;
+      } else if (status === "disconnected") {
+        this.connected = false;
+      }
+      return;
+    }
+    if (msgType === "qr") {
+      return;
+    }
+    if (msgType === "error") {
+      return;
+    }
+  }
+};
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/index.ts
+var BUILTIN_CHANNEL_RUNTIMES = {
+  telegram: {
+    id: "telegram",
+    isEnabled: (config) => config.channels.telegram.enabled,
+    createChannel: (context) => new TelegramChannel(
+      context.config.channels.telegram,
+      context.bus,
+      context.config.providers.groq.apiKey,
+      context.sessionManager
+    )
+  },
+  whatsapp: {
+    id: "whatsapp",
+    isEnabled: (config) => config.channels.whatsapp.enabled,
+    createChannel: (context) => new WhatsAppChannel(context.config.channels.whatsapp, context.bus)
+  },
+  discord: {
+    id: "discord",
+    isEnabled: (config) => config.channels.discord.enabled,
+    createChannel: (context) => new DiscordChannel(context.config.channels.discord, context.bus)
+  },
+  feishu: {
+    id: "feishu",
+    isEnabled: (config) => config.channels.feishu.enabled,
+    createChannel: (context) => new FeishuChannel(context.config.channels.feishu, context.bus)
+  },
+  mochat: {
+    id: "mochat",
+    isEnabled: (config) => config.channels.mochat.enabled,
+    createChannel: (context) => new MochatChannel(context.config.channels.mochat, context.bus)
+  },
+  dingtalk: {
+    id: "dingtalk",
+    isEnabled: (config) => config.channels.dingtalk.enabled,
+    createChannel: (context) => new DingTalkChannel(context.config.channels.dingtalk, context.bus)
+  },
+  email: {
+    id: "email",
+    isEnabled: (config) => config.channels.email.enabled,
+    createChannel: (context) => new EmailChannel(context.config.channels.email, context.bus)
+  },
+  slack: {
+    id: "slack",
+    isEnabled: (config) => config.channels.slack.enabled,
+    createChannel: (context) => new SlackChannel(context.config.channels.slack, context.bus)
+  },
+  qq: {
+    id: "qq",
+    isEnabled: (config) => config.channels.qq.enabled,
+    createChannel: (context) => new QQChannel(context.config.channels.qq, context.bus)
+  }
+};
+var BUILTIN_CHANNEL_PLUGIN_IDS = Object.keys(BUILTIN_CHANNEL_RUNTIMES);
+function listBuiltinChannelRuntimes() {
+  return BUILTIN_CHANNEL_PLUGIN_IDS.map(
+    (channelId) => resolveBuiltinChannelRuntime(channelId)
+  );
+}
+function resolveBuiltinChannelRuntime(channelId) {
+  const runtime = BUILTIN_CHANNEL_RUNTIMES[channelId];
+  if (!runtime) {
+    throw new Error(`builtin channel runtime not found: ${channelId}`);
+  }
+  return runtime;
+}
+export {
+  BUILTIN_CHANNEL_PLUGIN_IDS,
+  DingTalkChannel,
+  DiscordChannel,
+  EmailChannel,
+  FeishuChannel,
+  MochatChannel,
+  QQChannel,
+  SlackChannel,
+  TelegramChannel,
+  WhatsAppChannel,
+  listBuiltinChannelRuntimes,
+  resolveBuiltinChannelRuntime
+};