@nextclaw/channel-runtime 0.2.3 → 0.2.4

package/dist/index.js

@@ -0,0 +1,4207 @@
+// src/channels/base.ts
+var BaseChannel = class {
+  constructor(config, bus) {
+    this.config = config;
+    this.bus = bus;
+  }
+  running = false;
+  async handleControlMessage(_msg) {
+    return 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,
+  REST,
+  Routes,
+  ApplicationCommandOptionType
+} 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/typing-controller.ts
+var ChannelTypingController = class {
+  heartbeatMs;
+  autoStopMs;
+  sendTyping;
+  tasks = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.heartbeatMs = Math.max(1e3, Math.floor(options.heartbeatMs));
+    this.autoStopMs = Math.max(this.heartbeatMs, Math.floor(options.autoStopMs));
+    this.sendTyping = options.sendTyping;
+  }
+  start(targetId) {
+    this.stop(targetId);
+    void this.sendTyping(targetId);
+    const heartbeat = setInterval(() => {
+      void this.sendTyping(targetId);
+    }, this.heartbeatMs);
+    const autoStop = setTimeout(() => {
+      this.stop(targetId);
+    }, this.autoStopMs);
+    this.tasks.set(targetId, {
+      heartbeat,
+      autoStop
+    });
+  }
+  stop(targetId) {
+    const task = this.tasks.get(targetId);
+    if (!task) {
+      return;
+    }
+    clearInterval(task.heartbeat);
+    clearTimeout(task.autoStop);
+    this.tasks.delete(targetId);
+  }
+  stopAll() {
+    for (const targetId of this.tasks.keys()) {
+      this.stop(targetId);
+    }
+  }
+};
+
+// src/channels/discord.ts
+import { CommandRegistry, isTypingStopControlMessage } from "@nextclaw/core";
+var DEFAULT_MEDIA_MAX_MB = 8;
+var MEDIA_FETCH_TIMEOUT_MS = 15e3;
+var TYPING_HEARTBEAT_MS = 6e3;
+var TYPING_AUTO_STOP_MS = 12e4;
+var DISCORD_TEXT_LIMIT = 2e3;
+var DISCORD_MAX_LINES_PER_MESSAGE = 17;
+var STREAM_EDIT_MIN_INTERVAL_MS = 600;
+var STREAM_MAX_UPDATES_PER_MESSAGE = 40;
+var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+var SLASH_GUILD_THRESHOLD = 10;
+var DiscordChannel = class extends BaseChannel {
+  constructor(config, bus, sessionManager, coreConfig) {
+    super(config, bus);
+    this.sessionManager = sessionManager;
+    this.coreConfig = coreConfig;
+    this.commandRegistry = this.coreConfig ? new CommandRegistry(this.coreConfig, this.sessionManager) : null;
+    this.typingController = new ChannelTypingController({
+      heartbeatMs: TYPING_HEARTBEAT_MS,
+      autoStopMs: TYPING_AUTO_STOP_MS,
+      sendTyping: async (channelId) => {
+        if (!this.client) {
+          return;
+        }
+        const channel = this.client.channels.cache.get(channelId);
+        if (!channel || !channel.isTextBased()) {
+          return;
+        }
+        const textChannel = channel;
+        await textChannel.sendTyping();
+      }
+    });
+  }
+  name = "discord";
+  client = null;
+  typingController;
+  commandRegistry;
+  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");
+      void this.registerSlashCommands();
+    });
+    this.client.on("messageCreate", async (message) => {
+      await this.handleIncoming(message);
+    });
+    this.client.on("interactionCreate", async (interaction) => {
+      await this.handleInteraction(interaction);
+    });
+    await this.client.login(this.config.token);
+  }
+  async stop() {
+    this.running = false;
+    this.typingController.stopAll();
+    if (this.client) {
+      await this.client.destroy();
+      this.client = null;
+    }
+  }
+  async handleControlMessage(msg) {
+    if (!isTypingStopControlMessage(msg)) {
+      return false;
+    }
+    this.stopTyping(msg.chatId);
+    return true;
+  }
+  async send(msg) {
+    if (isTypingStopControlMessage(msg)) {
+      this.stopTyping(msg.chatId);
+      return;
+    }
+    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 content = msg.content ?? "";
+    const textChunkLimit = resolveTextChunkLimit(this.config);
+    const chunks = chunkDiscordText(content, {
+      maxChars: textChunkLimit,
+      maxLines: DISCORD_MAX_LINES_PER_MESSAGE
+    });
+    if (chunks.length === 0) {
+      return;
+    }
+    const flags = msg.metadata?.silent === true ? MessageFlags.SuppressNotifications : void 0;
+    const streamingMode = resolveDiscordStreamingMode(this.config);
+    if (streamingMode === "off") {
+      await sendDiscordChunks({
+        textChannel,
+        chunks,
+        replyTo: msg.replyTo ?? void 0,
+        flags
+      });
+      return;
+    }
+    await sendDiscordDraftStreaming({
+      textChannel,
+      chunks,
+      replyTo: msg.replyTo ?? void 0,
+      flags,
+      draftChunk: resolveDraftChunkConfig(this.config, textChunkLimit),
+      streamingMode
+    });
+  }
+  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;
+    const isGroup = Boolean(message.guildId);
+    if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {
+      return;
+    }
+    const mentionState = this.resolveMentionState({ message, selfUserId, channelId, isGroup });
+    if (mentionState.requireMention && !mentionState.wasMentioned) {
+      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);
+    try {
+      await this.handleMessage({
+        senderId,
+        chatId: channelId,
+        content: contentParts.length ? contentParts.join("\n") : "[empty message]",
+        attachments,
+        metadata: {
+          message_id: message.id,
+          channel_id: channelId,
+          guild_id: message.guildId,
+          reply_to: replyTo,
+          account_id: this.resolveAccountId(),
+          accountId: this.resolveAccountId(),
+          is_group: isGroup,
+          peer_kind: isGroup ? "channel" : "direct",
+          peer_id: isGroup ? channelId : senderId,
+          was_mentioned: mentionState.wasMentioned,
+          require_mention: mentionState.requireMention,
+          ...attachmentIssues.length ? { attachment_issues: attachmentIssues } : {}
+        }
+      });
+    } catch (error) {
+      this.stopTyping(channelId);
+      throw error;
+    }
+  }
+  async handleInteraction(interaction) {
+    if (!interaction.isChatInputCommand()) {
+      return;
+    }
+    await this.handleSlashCommand(interaction);
+  }
+  async handleSlashCommand(interaction) {
+    if (!this.commandRegistry) {
+      await this.replyInteraction(interaction, "Slash commands are not available.", true);
+      return;
+    }
+    const channelId = interaction.channelId;
+    if (!channelId) {
+      await this.replyInteraction(interaction, "Slash commands are not available in this channel.", true);
+      return;
+    }
+    const senderId = interaction.user.id;
+    const isGroup = Boolean(interaction.guildId);
+    if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {
+      await this.replyInteraction(interaction, "You are not authorized to use commands here.", true);
+      return;
+    }
+    const args = {};
+    for (const option of interaction.options.data) {
+      if (typeof option.name === "string" && option.value !== void 0) {
+        args[option.name] = option.value;
+      }
+    }
+    try {
+      await interaction.deferReply({ ephemeral: true });
+      const result = await this.commandRegistry.execute(interaction.commandName, args, {
+        channel: this.name,
+        chatId: channelId,
+        senderId,
+        sessionKey: `${this.name}:${channelId}`
+      });
+      if (result.ephemeral === false) {
+        await interaction.editReply({ content: "Command executed." });
+        await interaction.followUp({ content: result.content, ephemeral: false });
+        return;
+      }
+      await interaction.editReply({ content: result.content });
+    } catch (error) {
+      await this.replyInteraction(interaction, "Command failed to execute.", true);
+      console.error(`Discord slash command error: ${String(error)}`);
+    }
+  }
+  async replyInteraction(interaction, content, ephemeral) {
+    const payload = { content, ephemeral };
+    if (interaction.deferred || interaction.replied) {
+      await interaction.followUp(payload);
+      return;
+    }
+    await interaction.reply(payload);
+  }
+  async registerSlashCommands() {
+    if (!this.client || !this.commandRegistry) {
+      return;
+    }
+    const appId = this.client.application?.id ?? this.client.user?.id;
+    if (!appId) {
+      return;
+    }
+    const commands = this.buildSlashCommandPayloads();
+    if (!commands.length) {
+      return;
+    }
+    const rest = new REST({ version: "10" }).setToken(this.config.token);
+    let guildIds = [];
+    try {
+      const guilds = await this.client.guilds.fetch();
+      guildIds = [...guilds.keys()];
+    } catch (error) {
+      console.error(`Failed to fetch Discord guild list: ${String(error)}`);
+    }
+    try {
+      if (guildIds.length > 0 && guildIds.length <= SLASH_GUILD_THRESHOLD) {
+        for (const guildId of guildIds) {
+          await rest.put(Routes.applicationGuildCommands(appId, guildId), { body: commands });
+        }
+        console.log(`Discord slash commands registered for ${guildIds.length} guild(s).`);
+      } else {
+        await rest.put(Routes.applicationCommands(appId), { body: commands });
+        console.log("Discord slash commands registered globally.");
+      }
+    } catch (error) {
+      console.error(`Failed to register Discord slash commands: ${String(error)}`);
+    }
+  }
+  buildSlashCommandPayloads() {
+    const specs = this.commandRegistry?.listSlashCommands() ?? [];
+    return specs.map((spec) => ({
+      name: spec.name,
+      description: spec.description,
+      options: mapCommandOptions(spec.options)
+    }));
+  }
+  resolveProxyAgent() {
+    const proxy = this.config.proxy?.trim();
+    if (!proxy) {
+      return null;
+    }
+    try {
+      return new ProxyAgent(proxy);
+    } catch {
+      return null;
+    }
+  }
+  resolveAccountId() {
+    const accountId = this.config.accountId?.trim();
+    return accountId || "default";
+  }
+  isAllowedByPolicy(params) {
+    if (!params.isGroup) {
+      if (this.config.dmPolicy === "disabled") {
+        return false;
+      }
+      const allowFrom = this.config.allowFrom ?? [];
+      if (this.config.dmPolicy === "allowlist" || this.config.dmPolicy === "pairing") {
+        return this.isAllowed(params.senderId);
+      }
+      if (allowFrom.includes("*")) {
+        return true;
+      }
+      return allowFrom.length === 0 ? true : this.isAllowed(params.senderId);
+    }
+    if (this.config.groupPolicy === "disabled") {
+      return false;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      const allowFrom = this.config.groupAllowFrom ?? [];
+      return allowFrom.includes("*") || allowFrom.includes(params.channelId);
+    }
+    return true;
+  }
+  resolveMentionState(params) {
+    if (!params.isGroup) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const groups = this.config.groups ?? {};
+    const groupRule = groups[params.channelId] ?? groups["*"];
+    const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;
+    if (!requireMention) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const patterns = [
+      ...this.config.mentionPatterns ?? [],
+      ...groupRule?.mentionPatterns ?? []
+    ].map((pattern) => pattern.trim()).filter(Boolean);
+    const content = params.message.content ?? "";
+    const wasMentionedByUserRef = Boolean(params.selfUserId) && params.message.mentions.users.has(params.selfUserId ?? "");
+    const wasMentionedByText = Boolean(params.selfUserId) && (content.includes(`<@${params.selfUserId}>`) || content.includes(`<@!${params.selfUserId}>`));
+    const wasMentionedByPattern = patterns.some((pattern) => {
+      try {
+        return new RegExp(pattern, "i").test(content);
+      } catch {
+        return content.toLowerCase().includes(pattern.toLowerCase());
+      }
+    });
+    return {
+      wasMentioned: wasMentionedByUserRef || wasMentionedByText || wasMentionedByPattern,
+      requireMention
+    };
+  }
+  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.typingController.start(channelId);
+  }
+  stopTyping(channelId) {
+    this.typingController.stop(channelId);
+  }
+};
+function mapCommandOptions(options) {
+  if (!options || options.length === 0) {
+    return void 0;
+  }
+  return options.map((option) => ({
+    name: option.name,
+    description: option.description,
+    type: mapCommandOptionType(option.type),
+    required: option.required ?? false
+  }));
+}
+function mapCommandOptionType(type) {
+  switch (type) {
+    case "boolean":
+      return ApplicationCommandOptionType.Boolean;
+    case "number":
+      return ApplicationCommandOptionType.Number;
+    case "string":
+    default:
+      return ApplicationCommandOptionType.String;
+  }
+}
+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"})`;
+}
+function countLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function parseFenceLine(line) {
+  const match = line.match(FENCE_RE);
+  if (!match) {
+    return null;
+  }
+  const indent = match[1] ?? "";
+  const marker = match[2] ?? "";
+  return {
+    indent,
+    markerChar: marker[0] ?? "`",
+    markerLen: marker.length,
+    openLine: line
+  };
+}
+function closeFenceLine(openFence) {
+  return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
+}
+function closeFenceIfNeeded(text, openFence) {
+  if (!openFence) {
+    return text;
+  }
+  const closeLine = closeFenceLine(openFence);
+  if (!text) {
+    return closeLine;
+  }
+  if (!text.endsWith("\n")) {
+    return `${text}
+${closeLine}`;
+  }
+  return `${text}${closeLine}`;
+}
+function splitLongLine(line, maxChars, opts) {
+  const limit = Math.max(1, Math.floor(maxChars));
+  if (line.length <= limit) {
+    return [line];
+  }
+  const chunks = [];
+  let remaining = line;
+  while (remaining.length > limit) {
+    if (opts.preserveWhitespace) {
+      chunks.push(remaining.slice(0, limit));
+      remaining = remaining.slice(limit);
+      continue;
+    }
+    const window = remaining.slice(0, limit);
+    let breakIndex = -1;
+    for (let index = window.length - 1; index >= 0; index -= 1) {
+      if (/\s/.test(window[index])) {
+        breakIndex = index;
+        break;
+      }
+    }
+    if (breakIndex <= 0) {
+      breakIndex = limit;
+    }
+    chunks.push(remaining.slice(0, breakIndex));
+    remaining = remaining.slice(breakIndex);
+  }
+  if (remaining.length) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+function chunkDiscordText(text, opts = {}) {
+  const maxChars = Math.max(1, Math.floor(opts.maxChars ?? DISCORD_TEXT_LIMIT));
+  const maxLines = Math.max(1, Math.floor(opts.maxLines ?? DISCORD_MAX_LINES_PER_MESSAGE));
+  const body = text ?? "";
+  if (!body) {
+    return [];
+  }
+  if (body.length <= maxChars && countLines(body) <= maxLines) {
+    return [body];
+  }
+  const lines = body.split("\n");
+  const chunks = [];
+  let current = "";
+  let currentLines = 0;
+  let openFence = null;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const payload = closeFenceIfNeeded(current, openFence);
+    if (payload.trim().length) {
+      chunks.push(payload);
+    }
+    current = "";
+    currentLines = 0;
+    if (openFence) {
+      current = openFence.openLine;
+      currentLines = 1;
+    }
+  };
+  for (const line of lines) {
+    const fenceInfo = parseFenceLine(line);
+    const wasInsideFence = openFence !== null;
+    let nextOpenFence = openFence;
+    if (fenceInfo) {
+      if (!openFence) {
+        nextOpenFence = fenceInfo;
+      } else if (openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= openFence.markerLen) {
+        nextOpenFence = null;
+      }
+    }
+    const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;
+    const reserveLines = nextOpenFence ? 1 : 0;
+    const effectiveMaxChars = maxChars - reserveChars;
+    const effectiveMaxLines = maxLines - reserveLines;
+    const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
+    const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
+    const prefixLength = current.length > 0 ? current.length + 1 : 0;
+    const segmentLimit = Math.max(1, charLimit - prefixLength);
+    const segments = splitLongLine(line, segmentLimit, {
+      preserveWhitespace: wasInsideFence
+    });
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+      const segment = segments[segmentIndex];
+      const isContinuation = segmentIndex > 0;
+      const delimiter = isContinuation ? "" : current.length > 0 ? "\n" : "";
+      const addition = `${delimiter}${segment}`;
+      const nextLength = current.length + addition.length;
+      const nextLineCount = currentLines + (isContinuation ? 0 : 1);
+      const exceedsChars = nextLength > charLimit;
+      const exceedsLines = nextLineCount > lineLimit;
+      if ((exceedsChars || exceedsLines) && current.length > 0) {
+        flush();
+      }
+      if (current.length > 0) {
+        current += addition;
+        if (!isContinuation) {
+          currentLines += 1;
+        }
+      } else {
+        current = segment;
+        currentLines = 1;
+      }
+    }
+    openFence = nextOpenFence;
+  }
+  if (current.length) {
+    const payload = closeFenceIfNeeded(current, openFence);
+    if (payload.trim().length) {
+      chunks.push(payload);
+    }
+  }
+  return chunks;
+}
+function clampInt(value, min, max) {
+  if (Number.isNaN(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function resolveTextChunkLimit(config) {
+  const configured = typeof config.textChunkLimit === "number" ? config.textChunkLimit : DISCORD_TEXT_LIMIT;
+  return clampInt(configured, 1, DISCORD_TEXT_LIMIT);
+}
+function resolveDiscordStreamingMode(config) {
+  const raw = config.streaming;
+  if (raw === true) {
+    return "partial";
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return "off";
+  }
+  if (raw === "progress") {
+    return "partial";
+  }
+  if (raw === "partial" || raw === "block" || raw === "off") {
+    return raw;
+  }
+  return "off";
+}
+function resolveDraftChunkConfig(config, textChunkLimit) {
+  const raw = config.draftChunk ?? {};
+  const minChars = clampInt(raw.minChars ?? 200, 1, textChunkLimit);
+  const maxChars = clampInt(raw.maxChars ?? 800, minChars, textChunkLimit);
+  const breakPreference = raw.breakPreference === "line" || raw.breakPreference === "none" ? raw.breakPreference : "paragraph";
+  return {
+    minChars,
+    maxChars,
+    breakPreference
+  };
+}
+function findDraftBreakIndex(text, start, end, preference) {
+  const slice = text.slice(start, end);
+  if (slice.length === 0) {
+    return null;
+  }
+  if (preference === "paragraph") {
+    const idx = slice.lastIndexOf("\n\n");
+    if (idx >= 0) {
+      return start + idx + 2;
+    }
+  }
+  if (preference === "paragraph" || preference === "line") {
+    const idx = slice.lastIndexOf("\n");
+    if (idx >= 0) {
+      return start + idx + 1;
+    }
+  }
+  for (let i = slice.length - 1; i >= 0; i -= 1) {
+    if (/\s/.test(slice[i])) {
+      return start + i + 1;
+    }
+  }
+  return null;
+}
+function splitDraftChunks(text, config) {
+  const chunks = [];
+  if (!text) {
+    return chunks;
+  }
+  let cursor = 0;
+  const length = text.length;
+  while (cursor < length) {
+    const remaining = length - cursor;
+    if (remaining <= config.maxChars) {
+      chunks.push(text.slice(cursor));
+      break;
+    }
+    const minEnd = Math.min(length, cursor + config.minChars);
+    const maxEnd = Math.min(length, cursor + config.maxChars);
+    let nextEnd = maxEnd;
+    const breakIndex = findDraftBreakIndex(text, minEnd, maxEnd, config.breakPreference);
+    if (breakIndex !== null && breakIndex > cursor) {
+      nextEnd = breakIndex;
+    }
+    if (nextEnd <= cursor) {
+      nextEnd = maxEnd;
+    }
+    chunks.push(text.slice(cursor, nextEnd));
+    cursor = nextEnd;
+  }
+  return chunks;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+async function sendDiscordChunks(params) {
+  const { textChannel, chunks, replyTo, flags } = params;
+  let first = true;
+  for (const chunk of chunks) {
+    const payload = {
+      content: chunk
+    };
+    if (first && replyTo) {
+      payload.reply = { messageReference: replyTo };
+    }
+    if (flags !== void 0) {
+      payload.flags = flags;
+    }
+    await textChannel.send(payload);
+    first = false;
+  }
+}
+async function sendDiscordDraftStreaming(params) {
+  const { textChannel, chunks, replyTo, flags, draftChunk, streamingMode } = params;
+  let first = true;
+  const effectiveDraftChunk = streamingMode === "block" ? draftChunk : {
+    ...draftChunk,
+    minChars: Math.max(1, Math.floor(draftChunk.minChars / 2)),
+    maxChars: Math.max(draftChunk.minChars, Math.floor(draftChunk.maxChars / 2))
+  };
+  for (const chunk of chunks) {
+    const draftChunks = splitDraftChunks(chunk, effectiveDraftChunk);
+    if (draftChunks.length === 0) {
+      continue;
+    }
+    if (draftChunks.length > STREAM_MAX_UPDATES_PER_MESSAGE) {
+      await sendDiscordChunks({
+        textChannel,
+        chunks: [chunk],
+        replyTo: first ? replyTo : void 0,
+        flags
+      });
+      first = false;
+      continue;
+    }
+    let draftMessage = null;
+    let current = "";
+    let lastEditAt = 0;
+    for (const draftPart of draftChunks) {
+      current += draftPart;
+      if (!draftMessage) {
+        const payload = {
+          content: current
+        };
+        if (first && replyTo) {
+          payload.reply = { messageReference: replyTo };
+        }
+        if (flags !== void 0) {
+          payload.flags = flags;
+        }
+        draftMessage = await textChannel.send(
+          payload
+        );
+        first = false;
+        lastEditAt = Date.now();
+        continue;
+      }
+      const waitMs = Math.max(0, lastEditAt + STREAM_EDIT_MIN_INTERVAL_MS - Date.now());
+      if (waitMs > 0) {
+        await sleep(waitMs);
+      }
+      try {
+        await draftMessage.edit({ content: current });
+      } catch {
+        await sendDiscordChunks({
+          textChannel,
+          chunks: [chunk],
+          replyTo: void 0,
+          flags
+        });
+        draftMessage = null;
+        break;
+      }
+      lastEditAt = Date.now();
+    }
+  }
+}
+
+// src/channels/email.ts
+import { ImapFlow } from "imapflow";
+import { simpleParser } from "mailparser";
+import nodemailer from "nodemailer";
+var sleep2 = (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 sleep2(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;
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+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 root = isRecord(data.event) ? data.event : data;
+    const message = root.message ?? data.message ?? {};
+    const sender = root.sender ?? message.sender ?? data.sender ?? {};
+    const senderIdObj = sender.sender_id ?? {};
+    const senderOpenId = senderIdObj.open_id || sender.open_id || "";
+    const senderUserId = senderIdObj.user_id || sender.user_id || "";
+    const senderUnionId = senderIdObj.union_id || sender.union_id || "";
+    const senderId = senderOpenId || senderUserId || senderUnionId || "";
+    const senderType = sender.sender_type ?? sender.senderType;
+    if (senderType === "bot") {
+      return;
+    }
+    const chatId = message.chat_id ?? "";
+    const chatType = message.chat_type ?? "";
+    const isGroup = chatType === "group";
+    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;
+    }
+    await this.handleMessage({
+      senderId: String(senderId),
+      // Always route by Feishu chat_id so DM/group sessions are stable.
+      chatId,
+      content,
+      attachments: [],
+      metadata: {
+        message_id: messageId,
+        chat_id: chatId,
+        chat_type: chatType,
+        msg_type: msgType,
+        is_group: isGroup,
+        peer_kind: isGroup ? "group" : "direct",
+        peer_id: chatId,
+        sender_open_id: senderOpenId || void 0,
+        sender_user_id: senderUserId || void 0,
+        sender_union_id: senderUnionId || void 0
+      }
+    });
+  }
+  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 sleep3(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 sleep3(sleepMs);
+      }
+      await sleep3(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 sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/channels/qq.ts
+import {
+  Bot,
+  ReceiverMode,
+  SessionEvents
+} from "qq-official-bot";
+var QQChannel = class extends BaseChannel {
+  name = "qq";
+  bot = null;
+  processedIds = [];
+  processedSet = /* @__PURE__ */ new Set();
+  senderNameCache = /* @__PURE__ */ new Map();
+  reconnectTimer = null;
+  connectTask = null;
+  reconnectAttempt = 0;
+  reconnectBaseMs = 1e3;
+  reconnectMaxMs = 6e4;
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.appId || !this.config.secret) {
+      this.running = false;
+      throw new Error("QQ appId/appSecret not configured");
+    }
+    this.running = true;
+    this.reconnectAttempt = 0;
+    this.clearReconnectTimer();
+    this.tryConnect("startup");
+  }
+  async stop() {
+    this.running = false;
+    this.clearReconnectTimer();
+    this.reconnectAttempt = 0;
+    await this.teardownBot();
+    if (this.connectTask) {
+      await this.connectTask;
+    }
+  }
+  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 rawContent = msg.content ?? "";
+    const payload = rawContent;
+    try {
+      await this.sendByMessageType({ messageType, qqMeta, msg, payload, source });
+    } catch (error) {
+      if (!this.isDisallowedUrlParamError(error)) {
+        throw error;
+      }
+      const safeText = this.toQqSafeText(rawContent, error);
+      await this.sendByMessageType({ messageType, qqMeta, msg, payload: safeText, source });
+    }
+  }
+  async sendByMessageType(params) {
+    const { messageType, qqMeta, msg, payload, source } = params;
+    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 normalizedContent = content || "[empty message]";
+    const eventSenderName = this.resolveSenderName(rawEvent);
+    if (eventSenderName) {
+      this.senderNameCache.set(senderId, eventSenderName);
+    }
+    const declaredName = this.extractDeclaredName(normalizedContent);
+    if (declaredName) {
+      this.senderNameCache.set(senderId, declaredName);
+    }
+    const senderName = declaredName ?? eventSenderName ?? this.senderNameCache.get(senderId) ?? null;
+    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;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
+    } 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;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
+    } else if (event.sub_type === "direct") {
+      messageType = "direct";
+      chatId = event.guild_id ?? "";
+      qqMeta.guildId = event.guild_id;
+      qqMeta.userId = senderId;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
+    } else {
+      qqMeta.userId = senderId;
+      if (senderName) {
+        qqMeta.userName = senderName;
+      }
+    }
+    qqMeta.messageType = messageType;
+    const safeContent = this.decorateSpeakerPrefix({
+      content: normalizedContent,
+      messageType,
+      senderId,
+      senderName
+    });
+    if (!chatId) {
+      return;
+    }
+    if (!this.isAllowed(senderId)) {
+      return;
+    }
+    await this.handleMessage({
+      senderId,
+      chatId,
+      content: safeContent,
+      attachments: [],
+      metadata: {
+        message_id: messageId,
+        qq: qqMeta
+      }
+    });
+  }
+  resolveSenderName(rawEvent) {
+    const candidates = [
+      rawEvent.sender?.card,
+      rawEvent.sender?.nickname,
+      rawEvent.sender?.nick,
+      rawEvent.sender?.username,
+      rawEvent.sender?.user_name
+    ];
+    for (const value of candidates) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      const normalized = value.trim();
+      if (normalized) {
+        return normalized;
+      }
+    }
+    return null;
+  }
+  decorateSpeakerPrefix(params) {
+    const userId = this.sanitizeSpeakerToken(params.senderId);
+    if (!userId) {
+      return params.content;
+    }
+    const name = this.sanitizeSpeakerToken(params.senderName ?? "");
+    const speakerFields = [`user_id=${userId}`];
+    if (name) {
+      speakerFields.push(`name=${name}`);
+    }
+    return `[speaker:${speakerFields.join(";")}] ${params.content}`;
+  }
+  sanitizeSpeakerToken(value) {
+    return value.replace(/[\r\n;\]]/g, " ").trim();
+  }
+  extractDeclaredName(content) {
+    const trimmed = content.trim();
+    const patterns = [
+      /^我的昵称是\s*([^\s，。！？!?,]{1,24})$/u,
+      /^我叫\s*([^\s，。！？!?,]{1,24})$/u,
+      /^叫我\s*([^\s，。！？!?,]{1,24})$/u
+    ];
+    for (const pattern of patterns) {
+      const match = trimmed.match(pattern);
+      if (!match) {
+        continue;
+      }
+      const candidate = this.sanitizeSpeakerToken(match[1] ?? "");
+      if (candidate) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  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");
+  }
+  isDisallowedUrlParamError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("code(40034028)") || message.includes("\u8BF7\u6C42\u53C2\u6570\u4E0D\u5141\u8BB8\u5305\u542Burl");
+  }
+  toQqSafeText(content, error) {
+    let safe = content.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1").replace(/https?:\/\/\S+/gi, "[link]").replace(/www\.\S+/gi, "[link]").replace(/\b[a-z0-9._/-]+\.md\b/gi, "[file]");
+    const blocked = this.extractBlockedUrlToken(error);
+    if (blocked) {
+      safe = safe.replaceAll(blocked, "[link]");
+    }
+    return safe;
+  }
+  extractBlockedUrlToken(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const match = message.match(/包含url\s+([^\s]+)/);
+    if (!match) {
+      return null;
+    }
+    const token = match[1].trim();
+    return token.length > 0 ? token : null;
+  }
+  tryConnect(trigger) {
+    if (!this.running || this.bot || this.connectTask) {
+      return;
+    }
+    this.connectTask = this.connect(trigger).finally(() => {
+      this.connectTask = null;
+    });
+  }
+  async connect(trigger) {
+    let candidate = null;
+    try {
+      candidate = this.createBot();
+      await candidate.start();
+      if (!this.running) {
+        await this.safeStopBot(candidate);
+        return;
+      }
+      this.bot = candidate;
+      this.reconnectAttempt = 0;
+      console.log("QQ bot connected");
+    } catch (error) {
+      if (candidate) {
+        await this.safeStopBot(candidate);
+      }
+      if (!this.running) {
+        return;
+      }
+      this.reconnectAttempt += 1;
+      const delayMs = this.getBackoffDelayMs(this.reconnectAttempt);
+      console.error(
+        `[qq] start failed (${trigger}, attempt ${this.reconnectAttempt}), retry in ${delayMs}ms: ${this.formatError(error)}`
+      );
+      this.scheduleReconnect(delayMs, `${trigger}-retry`);
+    }
+  }
+  createBot() {
+    const 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"
+    });
+    bot.on("message.private", async (event) => {
+      await this.handleIncoming(event);
+    });
+    bot.on("message.group", async (event) => {
+      await this.handleIncoming(event);
+    });
+    bot.sessionManager.on(SessionEvents.DEAD, () => {
+      void this.handleSessionDead(bot);
+    });
+    return bot;
+  }
+  async handleSessionDead(bot) {
+    if (!this.running || this.bot !== bot) {
+      return;
+    }
+    this.bot = null;
+    await this.safeStopBot(bot);
+    this.reconnectAttempt += 1;
+    const delayMs = this.getBackoffDelayMs(this.reconnectAttempt);
+    console.error(`[qq] session dead, reconnect in ${delayMs}ms`);
+    this.scheduleReconnect(delayMs, "session-dead");
+  }
+  scheduleReconnect(delayMs, trigger) {
+    if (!this.running) {
+      return;
+    }
+    this.clearReconnectTimer();
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.tryConnect(trigger);
+    }, delayMs);
+  }
+  clearReconnectTimer() {
+    if (!this.reconnectTimer) {
+      return;
+    }
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+  async teardownBot() {
+    if (!this.bot) {
+      return;
+    }
+    const bot = this.bot;
+    this.bot = null;
+    await this.safeStopBot(bot);
+  }
+  async safeStopBot(bot) {
+    bot.removeAllListeners("message.private");
+    bot.removeAllListeners("message.group");
+    bot.sessionManager.removeAllListeners(SessionEvents.DEAD);
+    try {
+      await bot.stop();
+    } catch {
+    }
+  }
+  getBackoffDelayMs(attempt) {
+    const jitter = Math.floor(Math.random() * 500);
+    const exp = Math.min(this.reconnectMaxMs, this.reconnectBaseMs * 2 ** Math.max(0, attempt - 1));
+    return Math.min(this.reconnectMaxMs, exp + jitter);
+  }
+  formatError(error) {
+    if (error instanceof Error) {
+      return error.stack ?? error.message;
+    }
+    return String(error);
+  }
+};
+
+// 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";
+import {
+  isAssistantStreamResetControlMessage,
+  isTypingStopControlMessage as isTypingStopControlMessage2,
+  readAssistantStreamDelta
+} from "@nextclaw/core";
+var TYPING_HEARTBEAT_MS2 = 6e3;
+var TYPING_AUTO_STOP_MS2 = 12e4;
+var TELEGRAM_TEXT_LIMIT = 4096;
+var STREAM_PREVIEW_MIN_CHARS = 30;
+var STREAM_PREVIEW_PARTIAL_MIN_INTERVAL_MS = 700;
+var STREAM_PREVIEW_BLOCK_MIN_INTERVAL_MS = 1200;
+var STREAM_PREVIEW_BLOCK_MIN_GROWTH = 120;
+var BOT_COMMANDS = [
+  { command: "start", description: "Start the bot" },
+  { command: "reset", description: "Reset conversation history" },
+  { command: "help", description: "Show available commands" }
+];
+var TelegramStreamPreviewController = class {
+  constructor(params) {
+    this.params = params;
+  }
+  states = /* @__PURE__ */ new Map();
+  async handleReset(msg) {
+    const chatId = String(msg.chatId);
+    this.dispose(chatId);
+    if (this.params.resolveMode() === "off") {
+      return;
+    }
+    const replyToMessageId = readReplyToMessageId(msg.metadata);
+    this.states.set(chatId, {
+      chatId,
+      rawText: "",
+      lastRenderedText: "",
+      messageId: void 0,
+      replyToMessageId,
+      silent: msg.metadata?.silent === true,
+      lastSentAt: 0,
+      lastEmittedChars: 0,
+      inFlight: false,
+      pending: false,
+      timer: null
+    });
+  }
+  async handleDelta(msg, delta) {
+    if (!delta) {
+      return;
+    }
+    if (this.params.resolveMode() === "off") {
+      return;
+    }
+    const chatId = String(msg.chatId);
+    const state = this.ensureState(chatId);
+    state.rawText += delta;
+    this.scheduleFlush(state);
+  }
+  async finalizeWithFinalMessage(msg) {
+    if (this.params.resolveMode() === "off") {
+      return false;
+    }
+    const chatId = String(msg.chatId);
+    const state = this.states.get(chatId);
+    if (!state) {
+      return false;
+    }
+    state.rawText = msg.content ?? "";
+    const replyToMessageId = msg.replyTo ? Number(msg.replyTo) : state.replyToMessageId;
+    state.silent = msg.metadata?.silent === true || state.silent;
+    if (!state.rawText.trim()) {
+      this.dispose(chatId);
+      return false;
+    }
+    const handled = await this.flushNow(state, {
+      force: true,
+      allowInitialBelowThreshold: true,
+      replyToMessageId,
+      silent: state.silent
+    });
+    this.dispose(chatId);
+    return handled;
+  }
+  stopAll() {
+    for (const chatId of this.states.keys()) {
+      this.dispose(chatId);
+    }
+  }
+  ensureState(chatId) {
+    const existing = this.states.get(chatId);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      chatId,
+      rawText: "",
+      lastRenderedText: "",
+      messageId: void 0,
+      replyToMessageId: void 0,
+      silent: false,
+      lastSentAt: 0,
+      lastEmittedChars: 0,
+      inFlight: false,
+      pending: false,
+      timer: null
+    };
+    this.states.set(chatId, created);
+    return created;
+  }
+  scheduleFlush(state) {
+    if (state.timer) {
+      return;
+    }
+    const minInterval = this.params.resolveMode() === "block" ? STREAM_PREVIEW_BLOCK_MIN_INTERVAL_MS : STREAM_PREVIEW_PARTIAL_MIN_INTERVAL_MS;
+    const delay = Math.max(0, minInterval - (Date.now() - state.lastSentAt));
+    state.timer = setTimeout(() => {
+      state.timer = null;
+      void this.flushScheduled(state);
+    }, delay);
+  }
+  async flushScheduled(state) {
+    const current = this.states.get(state.chatId);
+    if (current !== state) {
+      return;
+    }
+    if (state.inFlight) {
+      state.pending = true;
+      return;
+    }
+    state.inFlight = true;
+    try {
+      await this.flushNow(state, {
+        force: false,
+        allowInitialBelowThreshold: false,
+        replyToMessageId: state.replyToMessageId,
+        silent: state.silent
+      });
+    } finally {
+      state.inFlight = false;
+      if (state.pending) {
+        state.pending = false;
+        this.scheduleFlush(state);
+      }
+    }
+  }
+  async flushNow(state, opts) {
+    const bot = this.params.getBot();
+    if (!bot) {
+      return false;
+    }
+    const plainText = state.rawText.trimEnd();
+    if (!plainText) {
+      return false;
+    }
+    const mode = this.params.resolveMode();
+    if (mode === "block" && !opts.force && plainText.length - state.lastEmittedChars < STREAM_PREVIEW_BLOCK_MIN_GROWTH) {
+      return typeof state.messageId === "number";
+    }
+    if (typeof state.messageId !== "number" && !opts.allowInitialBelowThreshold && plainText.length < STREAM_PREVIEW_MIN_CHARS) {
+      return false;
+    }
+    const renderedText = markdownToTelegramHtml(plainText).trimEnd();
+    if (!renderedText) {
+      return false;
+    }
+    const limitedRenderedText = renderedText.slice(0, TELEGRAM_TEXT_LIMIT);
+    if (limitedRenderedText === state.lastRenderedText) {
+      return typeof state.messageId === "number";
+    }
+    if (typeof state.messageId === "number") {
+      try {
+        await bot.editMessageText(limitedRenderedText, {
+          chat_id: Number(state.chatId),
+          message_id: state.messageId,
+          parse_mode: "HTML"
+        });
+      } catch {
+        try {
+          await bot.editMessageText(plainText.slice(0, TELEGRAM_TEXT_LIMIT), {
+            chat_id: Number(state.chatId),
+            message_id: state.messageId
+          });
+        } catch {
+          return false;
+        }
+      }
+      state.lastRenderedText = limitedRenderedText;
+      state.lastSentAt = Date.now();
+      state.lastEmittedChars = plainText.length;
+      return true;
+    }
+    const sendOptions = {
+      parse_mode: "HTML",
+      ...opts.replyToMessageId ? { reply_to_message_id: opts.replyToMessageId } : {},
+      ...opts.silent ? { disable_notification: true } : {}
+    };
+    try {
+      const sent = await bot.sendMessage(Number(state.chatId), limitedRenderedText, sendOptions);
+      if (typeof sent.message_id === "number") {
+        state.messageId = sent.message_id;
+      }
+    } catch {
+      const sent = await bot.sendMessage(Number(state.chatId), plainText.slice(0, TELEGRAM_TEXT_LIMIT), {
+        ...opts.replyToMessageId ? { reply_to_message_id: opts.replyToMessageId } : {},
+        ...opts.silent ? { disable_notification: true } : {}
+      });
+      if (typeof sent.message_id === "number") {
+        state.messageId = sent.message_id;
+      }
+    }
+    state.lastRenderedText = limitedRenderedText;
+    state.lastSentAt = Date.now();
+    state.lastEmittedChars = plainText.length;
+    return true;
+  }
+  dispose(chatId) {
+    const state = this.states.get(chatId);
+    if (!state) {
+      return;
+    }
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    this.states.delete(chatId);
+  }
+};
+var TelegramChannel = class extends BaseChannel {
+  constructor(config, bus, groqApiKey, sessionManager) {
+    super(config, bus);
+    this.sessionManager = sessionManager;
+    this.transcriber = new GroqTranscriptionProvider(groqApiKey ?? null);
+    this.typingController = new ChannelTypingController({
+      heartbeatMs: TYPING_HEARTBEAT_MS2,
+      autoStopMs: TYPING_AUTO_STOP_MS2,
+      sendTyping: async (chatId) => {
+        await this.bot?.sendChatAction(Number(chatId), "typing");
+      }
+    });
+    this.streamPreview = new TelegramStreamPreviewController({
+      resolveMode: () => resolveTelegramStreamingMode(this.config),
+      getBot: () => this.bot
+    });
+  }
+  name = "telegram";
+  bot = null;
+  botUserId = null;
+  botUsername = null;
+  typingController;
+  streamPreview;
+  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);
+    try {
+      const me = await this.bot.getMe();
+      this.botUserId = me.id;
+      this.botUsername = me.username ?? null;
+    } catch {
+      this.botUserId = null;
+      this.botUsername = null;
+    }
+    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 accountId = this.resolveAccountId();
+      const candidates = this.sessionManager.listSessions().filter((entry) => {
+        const metadata = entry.metadata ?? {};
+        const lastChannel = typeof metadata.last_channel === "string" ? metadata.last_channel : "";
+        const lastTo = typeof metadata.last_to === "string" ? metadata.last_to : "";
+        const lastAccountId = typeof metadata.last_account_id === "string" ? metadata.last_account_id : typeof metadata.last_accountId === "string" ? metadata.last_accountId : "default";
+        return lastChannel === this.name && lastTo === chatId && lastAccountId === accountId;
+      }).map((entry) => String(entry.key ?? "")).filter(Boolean);
+      let totalCleared = 0;
+      for (const key of candidates) {
+        const session = this.sessionManager.getIfExists(key);
+        if (!session) {
+          continue;
+        }
+        totalCleared += session.messages.length;
+        this.sessionManager.clear(session);
+        this.sessionManager.save(session);
+      }
+      if (candidates.length === 0) {
+        const legacySession = this.sessionManager.getOrCreate(`${this.name}:${chatId}`);
+        totalCleared = legacySession.messages.length;
+        this.sessionManager.clear(legacySession);
+        this.sessionManager.save(legacySession);
+      }
+      await this.bot?.sendMessage(msg.chat.id, `\u{1F504} Conversation history cleared (${totalCleared} 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;
+    this.typingController.stopAll();
+    this.streamPreview.stopAll();
+    if (this.bot) {
+      await this.bot.stopPolling();
+      this.bot = null;
+    }
+  }
+  async handleControlMessage(msg) {
+    if (isTypingStopControlMessage2(msg)) {
+      this.stopTyping(msg.chatId);
+      return true;
+    }
+    if (isAssistantStreamResetControlMessage(msg)) {
+      await this.streamPreview.handleReset(msg);
+      return true;
+    }
+    const delta = readAssistantStreamDelta(msg);
+    if (delta !== null) {
+      await this.streamPreview.handleDelta(msg, delta);
+      return true;
+    }
+    return false;
+  }
+  async send(msg) {
+    if (isTypingStopControlMessage2(msg)) {
+      this.stopTyping(msg.chatId);
+      return;
+    }
+    if (!this.bot) {
+      return;
+    }
+    this.stopTyping(msg.chatId);
+    if (await this.streamPreview.finalizeWithFinalMessage(msg)) {
+      return;
+    }
+    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);
+    const isGroup = message.chat.type !== "private";
+    if (!this.isAllowedByPolicy({ senderId: String(sender.id), chatId, isGroup })) {
+      return;
+    }
+    const mentionState = this.resolveMentionState({ message, chatId, isGroup });
+    if (mentionState.requireMention && !mentionState.wasMentioned) {
+      return;
+    }
+    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}]`);
+      }
+    }
+    await this.maybeAddAckReaction({
+      message,
+      chatId,
+      isGroup,
+      mentionState
+    });
+    const content = contentParts.length ? contentParts.join("\n") : "[empty message]";
+    this.startTyping(chatId);
+    try {
+      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: isGroup,
+        account_id: this.resolveAccountId(),
+        accountId: this.resolveAccountId(),
+        peer_kind: isGroup ? "group" : "direct",
+        peer_id: isGroup ? chatId : String(sender.id),
+        was_mentioned: mentionState.wasMentioned,
+        require_mention: mentionState.requireMention
+      });
+    } catch (error) {
+      this.stopTyping(chatId);
+      throw error;
+    }
+  }
+  async dispatchToBus(senderId, chatId, content, attachments, metadata) {
+    await this.handleMessage({ senderId, chatId, content, attachments, metadata });
+  }
+  startTyping(chatId) {
+    this.typingController.start(chatId);
+  }
+  stopTyping(chatId) {
+    this.typingController.stop(chatId);
+  }
+  resolveAccountId() {
+    const accountId = this.config.accountId?.trim();
+    return accountId || "default";
+  }
+  async maybeAddAckReaction(params) {
+    if (!this.bot) {
+      return;
+    }
+    if (typeof params.message.message_id !== "number") {
+      return;
+    }
+    const emoji = (this.config.ackReaction ?? "\u{1F440}").trim();
+    if (!emoji) {
+      return;
+    }
+    const shouldAck = shouldSendAckReaction({
+      scope: this.config.ackReactionScope,
+      isDirect: !params.isGroup,
+      isGroup: params.isGroup,
+      requireMention: params.mentionState.requireMention,
+      wasMentioned: params.mentionState.wasMentioned
+    });
+    if (!shouldAck) {
+      return;
+    }
+    const reaction = [{ type: "emoji", emoji }];
+    try {
+      await this.bot.setMessageReaction(Number(params.chatId), params.message.message_id, {
+        reaction
+      });
+    } catch {
+    }
+  }
+  isAllowedByPolicy(params) {
+    if (!params.isGroup) {
+      if (this.config.dmPolicy === "disabled") {
+        return false;
+      }
+      const allowFrom = this.config.allowFrom ?? [];
+      if (this.config.dmPolicy === "allowlist" || this.config.dmPolicy === "pairing") {
+        return this.isAllowed(params.senderId);
+      }
+      if (allowFrom.includes("*")) {
+        return true;
+      }
+      return allowFrom.length === 0 ? true : this.isAllowed(params.senderId);
+    }
+    if (this.config.groupPolicy === "disabled") {
+      return false;
+    }
+    if (this.config.groupPolicy === "allowlist") {
+      const allowFrom = this.config.groupAllowFrom ?? [];
+      return allowFrom.includes("*") || allowFrom.includes(params.chatId);
+    }
+    return true;
+  }
+  resolveMentionState(params) {
+    if (!params.isGroup) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const groups = this.config.groups ?? {};
+    const groupRule = groups[params.chatId] ?? groups["*"];
+    const requireMention = groupRule?.requireMention ?? this.config.requireMention ?? false;
+    if (!requireMention) {
+      return { wasMentioned: false, requireMention: false };
+    }
+    const content = `${params.message.text ?? ""}
+${params.message.caption ?? ""}`.trim();
+    const patterns = [
+      ...this.config.mentionPatterns ?? [],
+      ...groupRule?.mentionPatterns ?? []
+    ].map((pattern) => pattern.trim()).filter(Boolean);
+    const usernameMentioned = this.botUsername ? content.includes(`@${this.botUsername}`) : false;
+    const replyToBot = Boolean(this.botUserId) && Boolean(params.message.reply_to_message?.from) && params.message.reply_to_message?.from?.id === this.botUserId;
+    const patternMentioned = patterns.some((pattern) => {
+      try {
+        return new RegExp(pattern, "i").test(content);
+      } catch {
+        return content.toLowerCase().includes(pattern.toLowerCase());
+      }
+    });
+    return {
+      wasMentioned: usernameMentioned || replyToBot || patternMentioned,
+      requireMention
+    };
+  }
+};
+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 shouldSendAckReaction(params) {
+  const scope = params.scope ?? "all";
+  if (scope === "off") {
+    return false;
+  }
+  if (scope === "all") {
+    return true;
+  }
+  if (scope === "direct") {
+    return params.isDirect;
+  }
+  if (scope === "group-all") {
+    return params.isGroup;
+  }
+  if (scope === "group-mentions") {
+    return params.isGroup && params.requireMention && params.wasMentioned;
+  }
+  return false;
+}
+function readReplyToMessageId(metadata) {
+  const raw = metadata.message_id;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return Math.trunc(raw);
+  }
+  if (typeof raw === "string") {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed)) {
+      return Math.trunc(parsed);
+    }
+  }
+  return void 0;
+}
+function resolveTelegramStreamingMode(config) {
+  const raw = config.streaming;
+  if (raw === true) {
+    return "partial";
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return "off";
+  }
+  if (raw === "progress") {
+    return "partial";
+  }
+  if (raw === "partial" || raw === "block" || raw === "off") {
+    return raw;
+  }
+  return "off";
+}
+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/wecom.ts
+import { createHash } from "crypto";
+import { createServer } from "http";
+import { fetch as fetch5 } from "undici";
+var MSG_TYPE_FALLBACK = {
+  image: "[image]",
+  voice: "[voice]",
+  video: "[video]",
+  file: "[file]",
+  location: "[location]",
+  event: "[event]"
+};
+var TOKEN_EXPIRY_BUFFER_MS = 6e4;
+var WeComChannel = class extends BaseChannel {
+  name = "wecom";
+  server = null;
+  accessToken = null;
+  tokenExpiry = 0;
+  processedIds = [];
+  processedSet = /* @__PURE__ */ new Set();
+  constructor(config, bus) {
+    super(config, bus);
+  }
+  async start() {
+    if (!this.config.corpId || !this.config.agentId || !this.config.secret || !this.config.token) {
+      throw new Error("WeCom corpId/agentId/secret/token not configured");
+    }
+    this.running = true;
+    await new Promise((resolve, reject) => {
+      this.server = createServer((req, res) => {
+        void this.handleCallbackRequest(req, res);
+      });
+      this.server.once("error", reject);
+      this.server.listen(this.config.callbackPort, () => {
+        this.server?.off("error", reject);
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    this.running = false;
+    if (!this.server) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.server?.close(() => resolve());
+    });
+    this.server = null;
+  }
+  async send(msg) {
+    const receiver = msg.chatId?.trim();
+    if (!receiver) {
+      return;
+    }
+    const content = normalizeOutboundContent(msg);
+    if (!content) {
+      return;
+    }
+    const accessToken = await this.getAccessToken();
+    const sendUrl = `https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=${encodeURIComponent(accessToken)}`;
+    const agentIdNumber = Number(this.config.agentId);
+    const payload = {
+      touser: receiver,
+      msgtype: "text",
+      agentid: Number.isFinite(agentIdNumber) ? agentIdNumber : this.config.agentId,
+      text: {
+        content
+      },
+      safe: 0
+    };
+    const response = await fetch5(sendUrl, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`WeCom send failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    const errcode = Number(body.errcode ?? -1);
+    if (!Number.isFinite(errcode) || errcode !== 0) {
+      const errmsg = typeof body.errmsg === "string" ? body.errmsg : "unknown error";
+      throw new Error(`WeCom send failed: ${errcode} ${errmsg}`);
+    }
+  }
+  async handleCallbackRequest(req, res) {
+    const callbackPath = normalizeCallbackPath(this.config.callbackPath);
+    const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "127.0.0.1"}`);
+    if (requestUrl.pathname !== callbackPath) {
+      res.statusCode = 404;
+      res.end("not found");
+      return;
+    }
+    const method = (req.method ?? "GET").toUpperCase();
+    if (method === "GET") {
+      this.handleVerificationRequest(requestUrl, res);
+      return;
+    }
+    if (method === "POST") {
+      await this.handleInboundMessageRequest(req, requestUrl, res);
+      return;
+    }
+    res.statusCode = 405;
+    res.end("method not allowed");
+  }
+  handleVerificationRequest(requestUrl, res) {
+    const timestamp = requestUrl.searchParams.get("timestamp") ?? "";
+    const nonce = requestUrl.searchParams.get("nonce") ?? "";
+    const echostr = requestUrl.searchParams.get("echostr") ?? "";
+    const signature = requestUrl.searchParams.get("msg_signature") ?? requestUrl.searchParams.get("signature") ?? "";
+    if (!timestamp || !nonce || !echostr || !signature) {
+      res.statusCode = 400;
+      res.end("invalid verification payload");
+      return;
+    }
+    if (!this.verifySignature(timestamp, nonce, signature)) {
+      res.statusCode = 401;
+      res.end("signature mismatch");
+      return;
+    }
+    res.statusCode = 200;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end(echostr);
+  }
+  async handleInboundMessageRequest(req, requestUrl, res) {
+    const timestamp = requestUrl.searchParams.get("timestamp") ?? "";
+    const nonce = requestUrl.searchParams.get("nonce") ?? "";
+    const signature = requestUrl.searchParams.get("msg_signature") ?? requestUrl.searchParams.get("signature") ?? "";
+    if (!timestamp || !nonce || !signature || !this.verifySignature(timestamp, nonce, signature)) {
+      res.statusCode = 401;
+      res.end("signature mismatch");
+      return;
+    }
+    const rawBody = await readBody(req);
+    if (!rawBody.trim()) {
+      respondSuccess(res);
+      return;
+    }
+    if (extractXmlField(rawBody, "Encrypt")) {
+      respondSuccess(res);
+      return;
+    }
+    const senderId = extractXmlField(rawBody, "FromUserName");
+    if (!senderId || !this.isAllowed(senderId)) {
+      respondSuccess(res);
+      return;
+    }
+    const msgType = extractXmlField(rawBody, "MsgType") || "text";
+    const msgId = extractXmlField(rawBody, "MsgId") || buildSyntheticMessageId(rawBody, senderId, msgType);
+    if (this.isDuplicate(msgId)) {
+      respondSuccess(res);
+      return;
+    }
+    const content = extractXmlField(rawBody, "Content")?.trim() || MSG_TYPE_FALLBACK[msgType.toLowerCase()] || "[unsupported message]";
+    await this.handleMessage({
+      senderId,
+      chatId: senderId,
+      content,
+      attachments: [],
+      metadata: {
+        message_id: msgId,
+        wecom: {
+          msgType,
+          toUserName: extractXmlField(rawBody, "ToUserName"),
+          agentId: extractXmlField(rawBody, "AgentID"),
+          createTime: extractXmlField(rawBody, "CreateTime")
+        }
+      }
+    });
+    respondSuccess(res);
+  }
+  verifySignature(timestamp, nonce, signature) {
+    const expected = createHash("sha1").update([this.config.token, timestamp, nonce].sort().join("")).digest("hex");
+    return expected === signature;
+  }
+  async getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry) {
+      return this.accessToken;
+    }
+    const tokenUrl = `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${encodeURIComponent(this.config.corpId)}&corpsecret=${encodeURIComponent(this.config.secret)}`;
+    const response = await fetch5(tokenUrl, { method: "GET" });
+    if (!response.ok) {
+      throw new Error(`WeCom gettoken failed: HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    const errcode = Number(body.errcode ?? -1);
+    if (!Number.isFinite(errcode) || errcode !== 0) {
+      const errmsg = typeof body.errmsg === "string" ? body.errmsg : "unknown error";
+      throw new Error(`WeCom gettoken failed: ${errcode} ${errmsg}`);
+    }
+    const accessToken = typeof body.access_token === "string" ? body.access_token : "";
+    const expiresIn = Number(body.expires_in ?? 7200);
+    if (!accessToken) {
+      throw new Error("WeCom gettoken failed: missing access_token");
+    }
+    this.accessToken = accessToken;
+    this.tokenExpiry = Date.now() + Math.max(0, expiresIn * 1e3 - TOKEN_EXPIRY_BUFFER_MS);
+    return accessToken;
+  }
+  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;
+  }
+};
+function normalizeCallbackPath(path) {
+  if (!path) {
+    return "/wecom/callback";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function respondSuccess(res) {
+  res.statusCode = 200;
+  res.setHeader("content-type", "text/plain; charset=utf-8");
+  res.end("success");
+}
+function buildSyntheticMessageId(rawBody, senderId, msgType) {
+  return createHash("sha1").update(`${senderId}:${msgType}:${rawBody}`).digest("hex");
+}
+function extractXmlField(xml, field) {
+  const cdataPattern = new RegExp(`<${field}><!\\[CDATA\\[(.*?)\\]\\]><\\/${field}>`, "s");
+  const cdataMatch = xml.match(cdataPattern);
+  if (cdataMatch?.[1]) {
+    return cdataMatch[1].trim();
+  }
+  const textPattern = new RegExp(`<${field}>(.*?)<\\/${field}>`, "s");
+  const textMatch = xml.match(textPattern);
+  return textMatch?.[1]?.trim() ?? "";
+}
+async function readBody(req) {
+  const chunks = [];
+  return await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("error", reject);
+    req.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+  });
+}
+function normalizeOutboundContent(msg) {
+  const segments = [];
+  if (typeof msg.content === "string" && msg.content.trim()) {
+    segments.push(msg.content.trim());
+  }
+  if (Array.isArray(msg.media)) {
+    for (const item of msg.media) {
+      if (typeof item === "string" && item.trim()) {
+        segments.push(item.trim());
+      }
+    }
+  }
+  return segments.join("\n").trim();
+}
+
+// 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 sleep4(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 sleep4(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) => {
+      const providers = context.config.providers;
+      const groqApiKey = providers.groq?.apiKey;
+      return new TelegramChannel(
+        context.config.channels.telegram,
+        context.bus,
+        groqApiKey,
+        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, context.sessionManager, context.config)
+  },
+  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)
+  },
+  wecom: {
+    id: "wecom",
+    isEnabled: (config) => config.channels.wecom.enabled,
+    createChannel: (context) => new WeComChannel(context.config.channels.wecom, 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,
+  WeComChannel,
+  WhatsAppChannel,
+  listBuiltinChannelRuntimes,
+  resolveBuiltinChannelRuntime
+};