nextclaw 0.2.7 → 0.2.8

package/dist/cli/index.js

@@ -1,3321 +1,47 @@
 #!/usr/bin/env node
-import {
-  APP_NAME,
-  APP_REPLY_SUBJECT,
-  APP_TAGLINE,
-  APP_TITLE,
-  AgentLoop,
-  ConfigSchema,
-  LiteLLMProvider,
-  PROVIDERS,
-  SessionManager,
-  getApiBase,
-  getConfigPath,
-  getDataDir,
-  getDataPath,
-  getProvider,
-  getProviderName,
-  getWorkspacePath,
-  loadConfig,
-  saveConfig
-} from "../chunk-Z2YDZBBE.js";
-
-// src/cli/index.ts
-import { Command } from "commander";
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4,
-  cpSync,
-  rmSync,
-  openSync,
-  closeSync
-} from "fs";
-import { join as join6, resolve } from "path";
-import { spawn, spawnSync } from "child_process";
-import { createInterface } from "readline";
-import { fileURLToPath } from "url";
-import { createServer } from "net";
-import chokidar from "chokidar";
-
-// src/config/reload.ts
-var isPlainObject = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value)) {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var RELOAD_RULES = [
-  { prefix: "channels", kind: "restart-channels" },
-  { prefix: "providers", kind: "restart-required" },
-  { prefix: "agents.defaults.model", kind: "restart-required" },
-  { prefix: "agents.defaults.maxTokens", kind: "restart-required" },
-  { prefix: "agents.defaults.temperature", kind: "restart-required" },
-  { prefix: "agents.defaults.maxToolIterations", kind: "restart-required" },
-  { prefix: "tools", kind: "restart-required" },
-  { prefix: "gateway", kind: "none" },
-  { prefix: "ui", kind: "none" }
-];
-var matchRule = (path) => {
-  for (const rule of RELOAD_RULES) {
-    if (path === rule.prefix || path.startsWith(`${rule.prefix}.`)) {
-      return rule;
-    }
-  }
-  return null;
-};
-function diffConfigPaths(prev, next, prefix = "") {
-  if (prev === next) {
-    return [];
-  }
-  if (isPlainObject(prev) && isPlainObject(next)) {
-    const keys = /* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)]);
-    const paths = [];
-    for (const key of keys) {
-      const prevValue = prev[key];
-      const nextValue = next[key];
-      if (prevValue === void 0 && nextValue === void 0) {
-        continue;
-      }
-      const childPrefix = prefix ? `${prefix}.${key}` : key;
-      const childPaths = diffConfigPaths(prevValue, nextValue, childPrefix);
-      if (childPaths.length > 0) {
-        paths.push(...childPaths);
-      }
-    }
-    return paths;
-  }
-  if (Array.isArray(prev) && Array.isArray(next)) {
-    if (prev.length === next.length && prev.every((val, idx) => val === next[idx])) {
-      return [];
-    }
-  }
-  return [prefix || "<root>"];
-}
-function buildReloadPlan(changedPaths) {
-  const plan = {
-    changedPaths,
-    restartChannels: false,
-    restartRequired: [],
-    noopPaths: []
-  };
-  for (const path of changedPaths) {
-    const rule = matchRule(path);
-    if (!rule) {
-      plan.restartRequired.push(path);
-      continue;
-    }
-    if (rule.kind === "restart-channels") {
-      plan.restartChannels = true;
-      continue;
-    }
-    if (rule.kind === "restart-required") {
-      plan.restartRequired.push(path);
-      continue;
-    }
-    plan.noopPaths.push(path);
-  }
-  return plan;
-}
-
-// src/bus/queue.ts
-var AsyncQueue = class {
-  items = [];
-  waiters = [];
-  enqueue(item) {
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter(item);
-    } else {
-      this.items.push(item);
-    }
-  }
-  async dequeue() {
-    if (this.items.length > 0) {
-      return this.items.shift();
-    }
-    return new Promise((resolve2) => {
-      this.waiters.push(resolve2);
-    });
-  }
-  size() {
-    return this.items.length;
-  }
-};
-var MessageBus = class {
-  inboundQueue = new AsyncQueue();
-  outboundQueue = new AsyncQueue();
-  outboundSubscribers = {};
-  running = false;
-  async publishInbound(msg) {
-    this.inboundQueue.enqueue(msg);
-  }
-  async consumeInbound() {
-    return this.inboundQueue.dequeue();
-  }
-  async publishOutbound(msg) {
-    this.outboundQueue.enqueue(msg);
-  }
-  async consumeOutbound() {
-    return this.outboundQueue.dequeue();
-  }
-  subscribeOutbound(channel, callback) {
-    if (!this.outboundSubscribers[channel]) {
-      this.outboundSubscribers[channel] = [];
-    }
-    this.outboundSubscribers[channel].push(callback);
-  }
-  async dispatchOutbound() {
-    this.running = true;
-    while (this.running) {
-      const msg = await this.consumeOutbound();
-      const subscribers = this.outboundSubscribers[msg.channel] ?? [];
-      for (const callback of subscribers) {
-        try {
-          await callback(msg);
-        } catch (err2) {
-          console.error(`Error dispatching to ${msg.channel}: ${String(err2)}`);
-        }
-      }
-    }
-  }
-  stop() {
-    this.running = false;
-  }
-  get inboundSize() {
-    return this.inboundQueue.size();
-  }
-  get outboundSize() {
-    return this.outboundQueue.size();
-  }
-};
-
-// src/channels/telegram.ts
-import TelegramBot from "node-telegram-bot-api";
-
-// src/channels/base.ts
-var BaseChannel = class {
-  constructor(config, bus) {
-    this.config = config;
-    this.bus = bus;
-  }
-  running = false;
-  isAllowed(senderId) {
-    const allowList = this.config.allowFrom ?? [];
-    if (!allowList.length) {
-      return true;
-    }
-    if (allowList.includes(senderId)) {
-      return true;
-    }
-    if (senderId.includes("|")) {
-      return senderId.split("|").some((part) => allowList.includes(part));
-    }
-    return false;
-  }
-  async handleMessage(params) {
-    if (!this.isAllowed(params.senderId)) {
-      return;
-    }
-    const msg = {
-      channel: this.name,
-      senderId: params.senderId,
-      chatId: params.chatId,
-      content: params.content,
-      timestamp: /* @__PURE__ */ new Date(),
-      media: params.media ?? [],
-      metadata: params.metadata ?? {}
-    };
-    await this.bus.publishInbound(msg);
-  }
-  get isRunning() {
-    return this.running;
-  }
-};
-
-// src/providers/transcription.ts
-import { createReadStream, existsSync } from "fs";
-import { basename } from "path";
-import { FormData, fetch } 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 (!existsSync(filePath)) {
-      return "";
-    }
-    const form = new FormData();
-    form.append("file", createReadStream(filePath), basename(filePath));
-    form.append("model", "whisper-large-v3");
-    const response = await fetch(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 } from "path";
-import { mkdirSync } from "fs";
-var BOT_COMMANDS = [
-  { command: "start", description: "Start the bot" },
-  { command: "reset", description: "Reset conversation history" },
-  { command: "help", description: "Show available commands" }
-];
-var TelegramChannel = class extends BaseChannel {
-  constructor(config, bus, groqApiKey, sessionManager) {
-    super(config, bus);
-    this.sessionManager = sessionManager;
-    this.transcriber = new GroqTranscriptionProvider(groqApiKey ?? null);
-  }
-  name = "telegram";
-  bot = null;
-  typingTasks = /* @__PURE__ */ new Map();
-  transcriber;
-  async start() {
-    if (!this.config.token) {
-      throw new Error("Telegram bot token not configured");
-    }
-    this.running = true;
-    const options = { polling: true };
-    if (this.config.proxy) {
-      options.request = { proxy: this.config.proxy };
-    }
-    this.bot = new TelegramBot(this.config.token, options);
-    this.bot.onText(/^\/start$/, async (msg) => {
-      await this.bot?.sendMessage(
-        msg.chat.id,
-        `\u{1F44B} Hi ${msg.from?.first_name ?? ""}! I'm ${APP_NAME}.
-
-Send me a message and I'll respond!
-Type /help to see available commands.`
-      );
-    });
-    this.bot.onText(/^\/help$/, async (msg) => {
-      const helpText = `\u{1F916} <b>${APP_NAME} commands</b>
-
-/start \u2014 Start the bot
-/reset \u2014 Reset conversation history
-/help \u2014 Show this help message
-
-Just send me a text message to chat!`;
-      await this.bot?.sendMessage(msg.chat.id, helpText, { parse_mode: "HTML" });
-    });
-    this.bot.onText(/^\/reset$/, async (msg) => {
-      const chatId = String(msg.chat.id);
-      if (!this.sessionManager) {
-        await this.bot?.sendMessage(msg.chat.id, "\u26A0\uFE0F Session management is not available.");
-        return;
-      }
-      const sessionKey = `${this.name}:${chatId}`;
-      const session = this.sessionManager.getOrCreate(sessionKey);
-      const count = session.messages.length;
-      this.sessionManager.clear(session);
-      this.sessionManager.save(session);
-      await this.bot?.sendMessage(msg.chat.id, `\u{1F504} Conversation history cleared (${count} messages).`);
-    });
-    this.bot.on("message", async (msg) => {
-      if (!msg.text && !msg.caption && !msg.photo && !msg.voice && !msg.audio && !msg.document) {
-        return;
-      }
-      if (msg.text?.startsWith("/")) {
-        return;
-      }
-      await this.handleIncoming(msg);
-    });
-    await this.bot.setMyCommands(BOT_COMMANDS);
-  }
-  async stop() {
-    this.running = false;
-    for (const task of this.typingTasks.values()) {
-      clearInterval(task);
-    }
-    this.typingTasks.clear();
-    if (this.bot) {
-      await this.bot.stopPolling();
-      this.bot = null;
-    }
-  }
-  async send(msg) {
-    if (!this.bot) {
-      return;
-    }
-    this.stopTyping(msg.chatId);
-    const htmlContent = markdownToTelegramHtml(msg.content ?? "");
-    try {
-      await this.bot.sendMessage(Number(msg.chatId), htmlContent, { parse_mode: "HTML" });
-    } catch {
-      await this.bot.sendMessage(Number(msg.chatId), msg.content ?? "");
-    }
-  }
-  async handleIncoming(message) {
-    if (!this.bot || !message.from) {
-      return;
-    }
-    const chatId = String(message.chat.id);
-    let senderId = String(message.from.id);
-    if (message.from.username) {
-      senderId = `${senderId}|${message.from.username}`;
-    }
-    const contentParts = [];
-    const mediaPaths = [];
-    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 = join(getDataPath(), "media");
-      mkdirSync(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;
-      mediaPaths.push(finalPath);
-      if (mediaType === "voice" || mediaType === "audio") {
-        const transcription = await this.transcriber.transcribe(finalPath);
-        if (transcription) {
-          contentParts.push(`[transcription: ${transcription}]`);
-        } else {
-          contentParts.push(`[${mediaType}: ${finalPath}]`);
-        }
-      } else {
-        contentParts.push(`[${mediaType}: ${finalPath}]`);
-      }
-    }
-    const content = contentParts.length ? contentParts.join("\n") : "[empty message]";
-    this.startTyping(chatId);
-    await this.dispatchToBus(senderId, chatId, content, mediaPaths, {
-      message_id: message.message_id,
-      user_id: message.from.id,
-      username: message.from.username,
-      first_name: message.from.first_name,
-      is_group: message.chat.type !== "private"
-    });
-  }
-  async dispatchToBus(senderId, chatId, content, media, metadata) {
-    await this.handleMessage({ senderId, chatId, content, media, metadata });
-  }
-  startTyping(chatId) {
-    this.stopTyping(chatId);
-    if (!this.bot) {
-      return;
-    }
-    const task = setInterval(() => {
-      void this.bot?.sendChatAction(Number(chatId), "typing");
-    }, 4e3);
-    this.typingTasks.set(chatId, task);
-  }
-  stopTyping(chatId) {
-    const task = this.typingTasks.get(chatId);
-    if (task) {
-      clearInterval(task);
-      this.typingTasks.delete(chatId);
-    }
-  }
-};
-function 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 markdownToTelegramHtml(text) {
-  if (!text) {
-    return "";
-  }
-  const codeBlocks = [];
-  text = text.replace(/```[\w]*\n?([\s\S]*?)```/g, (_m, code) => {
-    codeBlocks.push(code);
-    return `\0CB${codeBlocks.length - 1}\0`;
-  });
-  const inlineCodes = [];
-  text = text.replace(/`([^`]+)`/g, (_m, code) => {
-    inlineCodes.push(code);
-    return `\0IC${inlineCodes.length - 1}\0`;
-  });
-  text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-  text = text.replace(/^>\s*(.*)$/gm, "$1");
-  text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-  text = text.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
-  text = text.replace(/__(.+?)__/g, "<b>$1</b>");
-  text = text.replace(/(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])/g, "<i>$1</i>");
-  text = text.replace(/~~(.+?)~~/g, "<s>$1</s>");
-  text = text.replace(/^[-*]\s+/gm, "\u2022 ");
-  inlineCodes.forEach((code, i) => {
-    const escaped = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    text = text.replace(`\0IC${i}\0`, `<code>${escaped}</code>`);
-  });
-  codeBlocks.forEach((code, i) => {
-    const escaped = code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    text = text.replace(`\0CB${i}\0`, `<pre><code>${escaped}</code></pre>`);
-  });
-  return text;
-}
-
-// src/channels/whatsapp.ts
-import WebSocket from "ws";
-var WhatsAppChannel = class extends BaseChannel {
-  name = "whatsapp";
-  ws = null;
-  connected = false;
-  constructor(config, bus) {
-    super(config, bus);
-  }
-  async start() {
-    this.running = true;
-    const bridgeUrl = this.config.bridgeUrl;
-    while (this.running) {
-      try {
-        await new Promise((resolve2, 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;
-            resolve2();
-          });
-          ws.on("error", (_err) => {
-            this.connected = false;
-            this.ws = null;
-            reject(_err);
-          });
-        });
-      } catch {
-        if (!this.running) {
-          break;
-        }
-        await sleep(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,
-        media: [],
-        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 sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// src/channels/discord.ts
-import {
-  Client,
-  GatewayIntentBits,
-  Partials
-} from "discord.js";
-import { fetch as fetch2 } from "undici";
-import { join as join2 } from "path";
-import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
-var MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-var DiscordChannel = class extends BaseChannel {
-  name = "discord";
-  client = null;
-  typingTasks = /* @__PURE__ */ new Map();
-  constructor(config, bus) {
-    super(config, bus);
-  }
-  async start() {
-    if (!this.config.token) {
-      throw new Error("Discord token not configured");
-    }
-    this.running = true;
-    this.client = new Client({
-      intents: this.config.intents ?? GatewayIntentBits.Guilds | GatewayIntentBits.GuildMessages | GatewayIntentBits.DirectMessages,
-      partials: [Partials.Channel]
-    });
-    this.client.on("ready", () => {
-      console.log("Discord bot connected");
-    });
-    this.client.on("messageCreate", async (message) => {
-      await this.handleIncoming(message);
-    });
-    await this.client.login(this.config.token);
-  }
-  async stop() {
-    this.running = false;
-    for (const task of this.typingTasks.values()) {
-      clearInterval(task);
-    }
-    this.typingTasks.clear();
-    if (this.client) {
-      await this.client.destroy();
-      this.client = null;
-    }
-  }
-  async send(msg) {
-    if (!this.client) {
-      return;
-    }
-    const channel = await this.client.channels.fetch(msg.chatId);
-    if (!channel || !channel.isTextBased()) {
-      return;
-    }
-    this.stopTyping(msg.chatId);
-    const textChannel = channel;
-    const payload = {
-      content: msg.content ?? ""
-    };
-    if (msg.replyTo) {
-      payload.reply = { messageReference: msg.replyTo };
-    }
-    await textChannel.send(payload);
-  }
-  async handleIncoming(message) {
-    if (message.author.bot) {
-      return;
-    }
-    const senderId = message.author.id;
-    const channelId = message.channelId;
-    if (!this.isAllowed(senderId)) {
-      return;
-    }
-    const contentParts = [];
-    const mediaPaths = [];
-    if (message.content) {
-      contentParts.push(message.content);
-    }
-    if (message.attachments.size) {
-      const mediaDir = join2(getDataPath(), "media");
-      mkdirSync2(mediaDir, { recursive: true });
-      for (const attachment of message.attachments.values()) {
-        if (attachment.size && attachment.size > MAX_ATTACHMENT_BYTES) {
-          contentParts.push(`[attachment: ${attachment.name ?? "file"} - too large]`);
-          continue;
-        }
-        try {
-          const res = await fetch2(attachment.url);
-          if (!res.ok) {
-            contentParts.push(`[attachment: ${attachment.name ?? "file"} - download failed]`);
-            continue;
-          }
-          const buffer = Buffer.from(await res.arrayBuffer());
-          const filename = `${attachment.id}_${(attachment.name ?? "file").replace(/\//g, "_")}`;
-          const filePath = join2(mediaDir, filename);
-          writeFileSync(filePath, buffer);
-          mediaPaths.push(filePath);
-          contentParts.push(`[attachment: ${filePath}]`);
-        } catch {
-          contentParts.push(`[attachment: ${attachment.name ?? "file"} - download failed]`);
-        }
-      }
-    }
-    const replyTo = message.reference?.messageId ?? null;
-    this.startTyping(channelId);
-    await this.handleMessage({
-      senderId,
-      chatId: channelId,
-      content: contentParts.length ? contentParts.join("\n") : "[empty message]",
-      media: mediaPaths,
-      metadata: {
-        message_id: message.id,
-        guild_id: message.guildId,
-        reply_to: replyTo
-      }
-    });
-  }
-  startTyping(channelId) {
-    this.stopTyping(channelId);
-    if (!this.client) {
-      return;
-    }
-    const channel = this.client.channels.cache.get(channelId);
-    if (!channel || !channel.isTextBased()) {
-      return;
-    }
-    const textChannel = channel;
-    const task = setInterval(() => {
-      void textChannel.sendTyping();
-    }, 8e3);
-    this.typingTasks.set(channelId, task);
-  }
-  stopTyping(channelId) {
-    const task = this.typingTasks.get(channelId);
-    if (task) {
-      clearInterval(task);
-      this.typingTasks.delete(channelId);
-    }
-  }
-};
-
-// src/channels/feishu.ts
-import * as Lark from "@larksuiteoapi/node-sdk";
-var MSG_TYPE_MAP = {
-  image: "[image]",
-  audio: "[audio]",
-  file: "[file]",
-  sticker: "[sticker]"
-};
-var TABLE_RE = /((?:^[ \t]*\|.+\|[ \t]*\n)(?:^[ \t]*\|[-:\s|]+\|[ \t]*\n)(?:^[ \t]*\|.+\|[ \t]*\n?)+)/gm;
-var FeishuChannel = class extends BaseChannel {
-  name = "feishu";
-  client = null;
-  wsClient = null;
-  processedMessageIds = [];
-  processedSet = /* @__PURE__ */ new Set();
-  constructor(config, bus) {
-    super(config, bus);
-  }
-  async start() {
-    if (!this.config.appId || !this.config.appSecret) {
-      throw new Error("Feishu appId/appSecret not configured");
-    }
-    this.running = true;
-    this.client = new Lark.Client({ appId: this.config.appId, appSecret: this.config.appSecret });
-    const dispatcher = new Lark.EventDispatcher({
-      encryptKey: this.config.encryptKey || void 0,
-      verificationToken: this.config.verificationToken || void 0
-    }).register({
-      "im.message.receive_v1": async (data) => {
-        await this.handleIncoming(data);
-      }
-    });
-    this.wsClient = new Lark.WSClient({
-      appId: this.config.appId,
-      appSecret: this.config.appSecret,
-      loggerLevel: Lark.LoggerLevel.info
-    });
-    this.wsClient.start({ eventDispatcher: dispatcher });
-  }
-  async stop() {
-    this.running = false;
-    if (this.wsClient) {
-      this.wsClient.close();
-      this.wsClient = null;
-    }
-  }
-  async send(msg) {
-    if (!this.client) {
-      return;
-    }
-    const receiveIdType = msg.chatId.startsWith("oc_") ? "chat_id" : "open_id";
-    const elements = buildCardElements(msg.content ?? "");
-    const card = {
-      config: { wide_screen_mode: true },
-      elements
-    };
-    const content = JSON.stringify(card);
-    await this.client.im.message.create({
-      params: { receive_id_type: receiveIdType },
-      data: {
-        receive_id: msg.chatId,
-        msg_type: "interactive",
-        content
-      }
-    });
-  }
-  async handleIncoming(data) {
-    const message = data.message ?? {};
-    const sender = message.sender ?? data.sender ?? {};
-    const senderIdObj = sender.sender_id ?? {};
-    const senderId = senderIdObj.open_id || senderIdObj.user_id || senderIdObj.union_id || sender.open_id || sender.user_id || "";
-    const senderType = sender.sender_type ?? sender.senderType;
-    if (senderType === "bot") {
-      return;
-    }
-    const chatId = message.chat_id ?? "";
-    const chatType = message.chat_type ?? "";
-    const msgType = message.msg_type ?? message.message_type ?? "";
-    const messageId = message.message_id ?? "";
-    if (!senderId || !chatId) {
-      return;
-    }
-    if (!this.isAllowed(String(senderId))) {
-      return;
-    }
-    if (messageId && this.isDuplicate(messageId)) {
-      return;
-    }
-    if (messageId) {
-      await this.addReaction(messageId, "THUMBSUP");
-    }
-    let content = "";
-    if (message.content) {
-      try {
-        const parsed = JSON.parse(String(message.content));
-        content = String(parsed.text ?? parsed.content ?? "");
-      } catch {
-        content = String(message.content);
-      }
-    }
-    if (!content && MSG_TYPE_MAP[msgType]) {
-      content = MSG_TYPE_MAP[msgType];
-    }
-    if (!content) {
-      return;
-    }
-    const replyTo = chatType === "group" ? chatId : String(senderId);
-    await this.handleMessage({
-      senderId: String(senderId),
-      chatId: replyTo,
-      content,
-      media: [],
-      metadata: {
-        message_id: messageId,
-        chat_type: chatType,
-        msg_type: msgType
-      }
-    });
-  }
-  isDuplicate(messageId) {
-    if (this.processedSet.has(messageId)) {
-      return true;
-    }
-    this.processedSet.add(messageId);
-    this.processedMessageIds.push(messageId);
-    if (this.processedMessageIds.length > 1e3) {
-      const removed = this.processedMessageIds.splice(0, 500);
-      for (const id of removed) {
-        this.processedSet.delete(id);
-      }
-    }
-    return false;
-  }
-  async addReaction(messageId, emojiType) {
-    if (!this.client) {
-      return;
-    }
-    try {
-      await this.client.im.messageReaction.create({
-        path: { message_id: messageId },
-        data: { reaction_type: { emoji_type: emojiType } }
-      });
-    } catch {
-    }
-  }
-};
-function buildCardElements(content) {
-  const elements = [];
-  let lastEnd = 0;
-  for (const match of content.matchAll(TABLE_RE)) {
-    const start = match.index ?? 0;
-    const tableText = match[1] ?? "";
-    const before = content.slice(lastEnd, start).trim();
-    if (before) {
-      elements.push({ tag: "markdown", content: before });
-    }
-    elements.push(parseMdTable(tableText) ?? { tag: "markdown", content: tableText });
-    lastEnd = start + tableText.length;
-  }
-  const remaining = content.slice(lastEnd).trim();
-  if (remaining) {
-    elements.push({ tag: "markdown", content: remaining });
-  }
-  if (!elements.length) {
-    elements.push({ tag: "markdown", content });
-  }
-  return elements;
-}
-function parseMdTable(tableText) {
-  const lines = tableText.trim().split("\n").map((line) => line.trim()).filter(Boolean);
-  if (lines.length < 3) {
-    return null;
-  }
-  const split = (line) => line.replace(/^\|+|\|+$/g, "").split("|").map((item) => item.trim());
-  const headers = split(lines[0]);
-  const rows = lines.slice(2).map(split);
-  const columns = headers.map((header, index) => ({
-    tag: "column",
-    name: `c${index}`,
-    display_name: header,
-    width: "auto"
-  }));
-  const tableRows = rows.map((row) => {
-    const values = {};
-    headers.forEach((_, index) => {
-      values[`c${index}`] = row[index] ?? "";
-    });
-    return values;
-  });
-  return {
-    tag: "table",
-    page_size: rows.length + 1,
-    columns,
-    rows: tableRows
-  };
-}
-
-// src/channels/mochat.ts
-import { io } from "socket.io-client";
-import { fetch as fetch3 } from "undici";
-import { join as join3 } from "path";
-import { mkdirSync as mkdirSync3, existsSync as existsSync2, 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 = join3(getDataPath(), "mochat");
-  cursorPath = join3(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");
-    }
-    mkdirSync3(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((resolve2) => {
-      const timer = setTimeout(() => resolve2(false), timeout);
-      socket.once("connect", () => {
-        clearTimeout(timer);
-        resolve2(true);
-      });
-      socket.once("connect_error", () => {
-        clearTimeout(timer);
-        resolve2(false);
-      });
-    });
-  }
-  async subscribeAll() {
-    const sessions = Array.from(this.sessionSet).sort();
-    const panels = Array.from(this.panelSet).sort();
-    let ok2 = await this.subscribeSessions(sessions);
-    ok2 = await this.subscribePanels(panels) && ok2;
-    if (this.autoDiscoverSessions || this.autoDiscoverPanels) {
-      await this.refreshTargets(true);
-    }
-    return ok2;
-  }
-  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((resolve2) => {
-      this.socket?.timeout(1e4).emit(eventName, payload, (err2, response) => {
-        if (err2) {
-          resolve2({ result: false, message: String(err2) });
-          return;
-        }
-        if (response && typeof response === "object") {
-          resolve2(response);
-          return;
-        }
-        resolve2({ result: true, data: response });
-      });
-    });
-  }
-  async refreshLoopTick() {
-    if (!this.running || this.refreshInFlight) {
-      return;
-    }
-    this.refreshInFlight = true;
-    try {
-      await this.refreshTargets(this.wsReady);
-      if (this.fallbackMode) {
-        await this.ensureFallbackWorkers();
-      }
-    } finally {
-      this.refreshInFlight = false;
-    }
-  }
-  async refreshTargets(subscribeNew) {
-    if (this.autoDiscoverSessions) {
-      await this.refreshSessionsDirectory(subscribeNew);
-    }
-    if (this.autoDiscoverPanels) {
-      await this.refreshPanels(subscribeNew);
-    }
-  }
-  async refreshSessionsDirectory(subscribeNew) {
-    let response;
-    try {
-      response = await this.postJson("/api/claw/sessions/list", {});
-    } catch {
-      return;
-    }
-    const sessions = response.sessions;
-    if (!Array.isArray(sessions)) {
-      return;
-    }
-    const newIds = [];
-    for (const session of sessions) {
-      const sid = strField(session, "sessionId");
-      if (!sid) {
-        continue;
-      }
-      if (!this.sessionSet.has(sid)) {
-        this.sessionSet.add(sid);
-        newIds.push(sid);
-        if (!(sid in this.sessionCursor)) {
-          this.coldSessions.add(sid);
-        }
-      }
-      const converseId = strField(session, "converseId");
-      if (converseId) {
-        this.sessionByConverse.set(converseId, sid);
-      }
-    }
-    if (!newIds.length) {
-      return;
-    }
-    if (this.wsReady && subscribeNew) {
-      await this.subscribeSessions(newIds);
-    }
-    if (this.fallbackMode) {
-      await this.ensureFallbackWorkers();
-    }
-  }
-  async refreshPanels(subscribeNew) {
-    let response;
-    try {
-      response = await this.postJson("/api/claw/groups/get", {});
-    } catch {
-      return;
-    }
-    const panels = response.panels;
-    if (!Array.isArray(panels)) {
-      return;
-    }
-    const newIds = [];
-    for (const panel of panels) {
-      const panelType = panel.type;
-      if (typeof panelType === "number" && panelType !== 0) {
-        continue;
-      }
-      const pid = strField(panel, "id", "_id");
-      if (pid && !this.panelSet.has(pid)) {
-        this.panelSet.add(pid);
-        newIds.push(pid);
-      }
-    }
-    if (!newIds.length) {
-      return;
-    }
-    if (this.wsReady && subscribeNew) {
-      await this.subscribePanels(newIds);
-    }
-    if (this.fallbackMode) {
-      await this.ensureFallbackWorkers();
-    }
-  }
-  async ensureFallbackWorkers() {
-    if (!this.running) {
-      return;
-    }
-    this.fallbackMode = true;
-    for (const sid of this.sessionSet) {
-      if (this.sessionFallbackTasks.has(sid)) {
-        continue;
-      }
-      const task = this.sessionWatchWorker(sid).finally(() => {
-        if (this.sessionFallbackTasks.get(sid) === task) {
-          this.sessionFallbackTasks.delete(sid);
-        }
-      });
-      this.sessionFallbackTasks.set(sid, task);
-    }
-    for (const pid of this.panelSet) {
-      if (this.panelFallbackTasks.has(pid)) {
-        continue;
-      }
-      const task = this.panelPollWorker(pid).finally(() => {
-        if (this.panelFallbackTasks.get(pid) === task) {
-          this.panelFallbackTasks.delete(pid);
-        }
-      });
-      this.panelFallbackTasks.set(pid, task);
-    }
-  }
-  async stopFallbackWorkers() {
-    this.fallbackMode = false;
-    const tasks = [...this.sessionFallbackTasks.values(), ...this.panelFallbackTasks.values()];
-    this.sessionFallbackTasks.clear();
-    this.panelFallbackTasks.clear();
-    await Promise.allSettled(tasks);
-  }
-  async sessionWatchWorker(sessionId) {
-    while (this.running && this.fallbackMode) {
-      try {
-        const payload = await this.postJson("/api/claw/sessions/watch", {
-          sessionId,
-          cursor: this.sessionCursor[sessionId] ?? 0,
-          timeoutMs: this.config.watchTimeoutMs,
-          limit: this.config.watchLimit
-        });
-        await this.handleWatchPayload(payload, "session");
-      } catch {
-        await sleep2(Math.max(100, this.config.retryDelayMs));
-      }
-    }
-  }
-  async panelPollWorker(panelId) {
-    const sleepMs = Math.max(1e3, this.config.refreshIntervalMs);
-    while (this.running && this.fallbackMode) {
-      try {
-        const payload = await this.postJson("/api/claw/groups/panels/messages", {
-          panelId,
-          limit: Math.min(100, Math.max(1, this.config.watchLimit))
-        });
-        const messages = payload.messages;
-        if (Array.isArray(messages)) {
-          for (const msg of [...messages].reverse()) {
-            const event = makeSyntheticEvent({
-              messageId: String(msg.messageId ?? ""),
-              author: String(msg.author ?? ""),
-              content: msg.content,
-              meta: msg.meta,
-              groupId: String(payload.groupId ?? ""),
-              converseId: panelId,
-              timestamp: msg.createdAt,
-              authorInfo: msg.authorInfo
-            });
-            await this.processInboundEvent(panelId, event, "panel");
-          }
-        }
-      } catch {
-        await sleep2(sleepMs);
-      }
-      await sleep2(sleepMs);
-    }
-  }
-  async handleWatchPayload(payload, targetKind) {
-    if (!payload || typeof payload !== "object") {
-      return;
-    }
-    const targetId = strField(payload, "sessionId");
-    if (!targetId) {
-      return;
-    }
-    const lockKey = `${targetKind}:${targetId}`;
-    const lock = this.targetLocks.get(lockKey) ?? new AsyncLock();
-    this.targetLocks.set(lockKey, lock);
-    await lock.run(async () => {
-      const previousCursor = this.sessionCursor[targetId] ?? 0;
-      const cursor = payload.cursor;
-      if (targetKind === "session" && typeof cursor === "number" && cursor >= 0) {
-        this.markSessionCursor(targetId, cursor);
-      }
-      const rawEvents = payload.events;
-      if (!Array.isArray(rawEvents)) {
-        return;
-      }
-      if (targetKind === "session" && this.coldSessions.has(targetId)) {
-        this.coldSessions.delete(targetId);
-        return;
-      }
-      for (const event of rawEvents) {
-        const seq = event.seq;
-        if (targetKind === "session" && typeof seq === "number" && seq > (this.sessionCursor[targetId] ?? previousCursor)) {
-          this.markSessionCursor(targetId, seq);
-        }
-        if (event.type === "message.add") {
-          await this.processInboundEvent(targetId, event, targetKind);
-        }
-      }
-    });
-  }
-  async processInboundEvent(targetId, event, targetKind) {
-    const payload = event.payload;
-    if (!payload) {
-      return;
-    }
-    const author = strField(payload, "author");
-    if (!author || this.config.agentUserId && author === this.config.agentUserId) {
-      return;
-    }
-    if (!this.isAllowed(author)) {
-      return;
-    }
-    const messageId = strField(payload, "messageId");
-    const seenKey = `${targetKind}:${targetId}`;
-    if (messageId && this.rememberMessageId(seenKey, messageId)) {
-      return;
-    }
-    const rawBody = normalizeMochatContent(payload.content) || "[empty message]";
-    const authorInfo = safeDict(payload.authorInfo);
-    const senderName = strField(authorInfo, "nickname", "email");
-    const senderUsername = strField(authorInfo, "agentId");
-    const groupId = strField(payload, "groupId");
-    const isGroup = Boolean(groupId);
-    const wasMentioned = resolveWasMentioned(payload, this.config.agentUserId);
-    const requireMention = targetKind === "panel" && isGroup && resolveRequireMention(this.config, targetId, groupId);
-    const useDelay = targetKind === "panel" && this.config.replyDelayMode === "non-mention";
-    if (requireMention && !wasMentioned && !useDelay) {
-      return;
-    }
-    const entry = {
-      rawBody,
-      author,
-      senderName,
-      senderUsername,
-      timestamp: parseTimestamp(event.timestamp),
-      messageId,
-      groupId
-    };
-    if (useDelay) {
-      const delayKey = seenKey;
-      if (wasMentioned) {
-        await this.flushDelayedEntries(delayKey, targetId, targetKind, true, entry);
-      } else {
-        await this.enqueueDelayedEntry(delayKey, targetId, targetKind, entry);
-      }
-      return;
-    }
-    await this.dispatchEntries(targetId, targetKind, [entry], wasMentioned);
-  }
-  rememberMessageId(key, messageId) {
-    const seenSet = this.seenSet.get(key) ?? /* @__PURE__ */ new Set();
-    const seenQueue = this.seenQueue.get(key) ?? [];
-    if (seenSet.has(messageId)) {
-      return true;
-    }
-    seenSet.add(messageId);
-    seenQueue.push(messageId);
-    while (seenQueue.length > MAX_SEEN_MESSAGE_IDS) {
-      const removed = seenQueue.shift();
-      if (removed) {
-        seenSet.delete(removed);
-      }
-    }
-    this.seenSet.set(key, seenSet);
-    this.seenQueue.set(key, seenQueue);
-    return false;
-  }
-  async enqueueDelayedEntry(key, targetId, targetKind, entry) {
-    const state = this.delayStates.get(key) ?? { entries: [], timer: null, lock: new AsyncLock() };
-    this.delayStates.set(key, state);
-    await state.lock.run(async () => {
-      state.entries.push(entry);
-      if (state.timer) {
-        clearTimeout(state.timer);
-      }
-      state.timer = setTimeout(() => {
-        void this.flushDelayedEntries(key, targetId, targetKind, false, null);
-      }, Math.max(0, this.config.replyDelayMs));
-    });
-  }
-  async flushDelayedEntries(key, targetId, targetKind, mentioned, entry) {
-    const state = this.delayStates.get(key) ?? { entries: [], timer: null, lock: new AsyncLock() };
-    this.delayStates.set(key, state);
-    let entries = [];
-    await state.lock.run(async () => {
-      if (entry) {
-        state.entries.push(entry);
-      }
-      if (state.timer) {
-        clearTimeout(state.timer);
-        state.timer = null;
-      }
-      entries = [...state.entries];
-      state.entries = [];
-    });
-    if (entries.length) {
-      await this.dispatchEntries(targetId, targetKind, entries, mentioned);
-    }
-  }
-  async dispatchEntries(targetId, targetKind, entries, wasMentioned) {
-    const last = entries[entries.length - 1];
-    const isGroup = Boolean(last.groupId);
-    const body = buildBufferedBody(entries, isGroup) || "[empty message]";
-    await this.handleMessage({
-      senderId: last.author,
-      chatId: targetId,
-      content: body,
-      media: [],
-      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 (!existsSync2(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 {
-      mkdirSync3(this.stateDir, { recursive: true });
-      const payload = {
-        schemaVersion: 1,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        cursors: this.sessionCursor
-      };
-      writeFileSync2(this.cursorPath, JSON.stringify(payload, null, 2) + "\n");
-    } catch {
-      return;
-    }
-  }
-  async postJson(path, payload) {
-    const url = `${this.config.baseUrl.trim().replace(/\/$/, "")}${path}`;
-    const response = await fetch3(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "X-Claw-Token": this.config.clawToken
-      },
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      throw new Error(`Mochat HTTP ${response.status}`);
-    }
-    let parsed;
-    try {
-      parsed = await response.json();
-    } catch {
-      parsed = await response.text();
-    }
-    if (parsed && typeof parsed === "object" && parsed.code !== void 0) {
-      const data = parsed;
-      if (typeof data.code === "number" && data.code !== 200) {
-        throw new Error(String(data.message ?? data.name ?? "request failed"));
-      }
-      if (data.data && typeof data.data === "object") {
-        return data.data;
-      }
-      return {};
-    }
-    if (parsed && typeof parsed === "object") {
-      return parsed;
-    }
-    return {};
-  }
-  async apiSend(path, idKey, idValue, content, replyTo, groupId) {
-    const body = { [idKey]: idValue, content };
-    if (replyTo) {
-      body.replyTo = replyTo;
-    }
-    if (groupId) {
-      body.groupId = groupId;
-    }
-    await this.postJson(path, body);
-  }
-};
-function normalizeIdList(values) {
-  const cleaned = values.map((value) => String(value).trim()).filter(Boolean);
-  const unique = Array.from(new Set(cleaned.filter((value) => value !== "*"))).sort();
-  return [unique, cleaned.includes("*")];
-}
-function safeDict(value) {
-  return value && typeof value === "object" ? value : {};
-}
-function strField(src, ...keys) {
-  for (const key of keys) {
-    const value = src[key];
-    if (typeof value === "string" && value.trim()) {
-      return value.trim();
-    }
-  }
-  return "";
-}
-function makeSyntheticEvent(params) {
-  const payload = {
-    messageId: params.messageId,
-    author: params.author,
-    content: params.content,
-    meta: safeDict(params.meta),
-    groupId: params.groupId,
-    converseId: params.converseId
-  };
-  if (params.authorInfo) {
-    payload.authorInfo = safeDict(params.authorInfo);
-  }
-  return {
-    type: "message.add",
-    timestamp: params.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-    payload
-  };
-}
-function normalizeMochatContent(content) {
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  if (content === null || content === void 0) {
-    return "";
-  }
-  try {
-    return JSON.stringify(content);
-  } catch {
-    return String(content);
-  }
-}
-function resolveMochatTarget(raw) {
-  const trimmed = (raw || "").trim();
-  if (!trimmed) {
-    return { id: "", isPanel: false };
-  }
-  const lowered = trimmed.toLowerCase();
-  let cleaned = trimmed;
-  let forcedPanel = false;
-  for (const prefix of ["mochat:", "group:", "channel:", "panel:"]) {
-    if (lowered.startsWith(prefix)) {
-      cleaned = trimmed.slice(prefix.length).trim();
-      forcedPanel = prefix !== "mochat:";
-      break;
-    }
-  }
-  if (!cleaned) {
-    return { id: "", isPanel: false };
-  }
-  return { id: cleaned, isPanel: forcedPanel || !cleaned.startsWith("session_") };
-}
-function extractMentionIds(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  const ids = [];
-  for (const item of value) {
-    if (typeof item === "string" && item.trim()) {
-      ids.push(item.trim());
-    } else if (item && typeof item === "object") {
-      const obj = item;
-      for (const key of ["id", "userId", "_id"]) {
-        const candidate = obj[key];
-        if (typeof candidate === "string" && candidate.trim()) {
-          ids.push(candidate.trim());
-          break;
-        }
-      }
-    }
-  }
-  return ids;
-}
-function resolveWasMentioned(payload, agentUserId) {
-  const meta = payload.meta;
-  if (meta) {
-    if (meta.mentioned === true || meta.wasMentioned === true) {
-      return true;
-    }
-    for (const field of ["mentions", "mentionIds", "mentionedUserIds", "mentionedUsers"]) {
-      if (agentUserId && extractMentionIds(meta[field]).includes(agentUserId)) {
-        return true;
-      }
-    }
-  }
-  if (!agentUserId) {
-    return false;
-  }
-  const content = payload.content;
-  if (typeof content !== "string" || !content) {
-    return false;
-  }
-  return content.includes(`<@${agentUserId}>`) || content.includes(`@${agentUserId}`);
-}
-function resolveRequireMention(config, sessionId, groupId) {
-  const groups = config.groups ?? {};
-  for (const key of [groupId, sessionId, "*"]) {
-    if (key && groups[key]) {
-      return Boolean(groups[key].requireMention);
-    }
-  }
-  return Boolean(config.mention.requireInGroups);
-}
-function buildBufferedBody(entries, isGroup) {
-  if (!entries.length) {
-    return "";
-  }
-  if (entries.length === 1) {
-    return entries[0].rawBody;
-  }
-  const lines = [];
-  for (const entry of entries) {
-    if (!entry.rawBody) {
-      continue;
-    }
-    if (isGroup) {
-      const label = entry.senderName.trim() || entry.senderUsername.trim() || entry.author;
-      if (label) {
-        lines.push(`${label}: ${entry.rawBody}`);
-        continue;
-      }
-    }
-    lines.push(entry.rawBody);
-  }
-  return lines.join("\n").trim();
-}
-function parseTimestamp(value) {
-  if (typeof value !== "string" || !value.trim()) {
-    return null;
-  }
-  const parsed = Date.parse(value);
-  return Number.isNaN(parsed) ? null : parsed;
-}
-function readGroupId(metadata) {
-  const value = metadata.group_id ?? metadata.groupId;
-  if (typeof value === "string" && value.trim()) {
-    return value.trim();
-  }
-  return null;
-}
-function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// src/channels/dingtalk.ts
-import { DWClient, EventAck, TOPIC_ROBOT } from "dingtalk-stream";
-import { fetch as fetch4 } 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 fetch4(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,
-      media: [],
-      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 fetch4(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/email.ts
-import { ImapFlow } from "imapflow";
-import { simpleParser } from "mailparser";
-import nodemailer from "nodemailer";
-var sleep3 = (ms) => new Promise((resolve2) => setTimeout(resolve2, 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,
-            media: [],
-            metadata: item.metadata ?? {}
-          });
-        }
-      } catch {
-      }
-      await sleep3(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/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;
-  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;
-    } catch {
-      this.botUserId = null;
-    }
-    await this.socketClient.start();
-  }
-  async stop() {
-    this.running = false;
-    if (this.socketClient) {
-      await this.socketClient.disconnect();
-      this.socketClient = 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;
-    }
-    if (event.subtype) {
-      return;
-    }
-    const senderId = event.user;
-    const chatId = event.channel;
-    const channelType = event.channel_type ?? "";
-    const text = event.text ?? "";
-    if (!senderId || !chatId) {
-      return;
-    }
-    if (this.botUserId && senderId === this.botUserId) {
-      return;
-    }
-    if (eventType === "message" && 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,
-      media: [],
-      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/qq.ts
-import {
-  Bot,
-  ReceiverMode,
-  segment
-} from "qq-official-bot";
-var QQChannel = class extends BaseChannel {
-  name = "qq";
-  bot = null;
-  processedIds = [];
-  processedSet = /* @__PURE__ */ new Set();
-  constructor(config, bus) {
-    super(config, bus);
-  }
-  async start() {
-    this.running = true;
-    if (!this.config.appId || !this.config.secret) {
-      throw new Error("QQ appId/appSecret not configured");
-    }
-    this.bot = new Bot({
-      appid: this.config.appId,
-      secret: this.config.secret,
-      mode: ReceiverMode.WEBSOCKET,
-      intents: ["C2C_MESSAGE_CREATE", "GROUP_AT_MESSAGE_CREATE"],
-      removeAt: true,
-      logLevel: "info"
-    });
-    this.bot.on("message.private", async (event) => {
-      await this.handleIncoming(event);
-    });
-    this.bot.on("message.group", async (event) => {
-      await this.handleIncoming(event);
-    });
-    await this.bot.start();
-    console.log("QQ bot connected");
-  }
-  async stop() {
-    this.running = false;
-    if (this.bot) {
-      this.bot.removeAllListeners("message.private");
-      this.bot.removeAllListeners("message.group");
-      await this.bot.stop();
-      this.bot = null;
-    }
-  }
-  async send(msg) {
-    if (!this.bot) {
-      return;
-    }
-    const qqMeta = msg.metadata?.qq ?? {};
-    const messageType = qqMeta.messageType ?? "private";
-    const metadataMessageId = msg.metadata?.message_id ?? null;
-    const sourceId = msg.replyTo ?? metadataMessageId ?? void 0;
-    const source = sourceId ? { id: sourceId } : void 0;
-    const content = this.normalizeContent(msg.content ?? "");
-    const payload = this.config.markdownSupport ? segment.markdown(content) : content;
-    if (messageType === "group") {
-      const groupId = qqMeta.groupId ?? msg.chatId;
-      await this.sendWithTokenRetry(() => this.bot?.sendGroupMessage(groupId, payload, source));
-      return;
-    }
-    if (messageType === "direct") {
-      const guildId = qqMeta.guildId ?? msg.chatId;
-      await this.sendWithTokenRetry(() => this.bot?.sendDirectMessage(guildId, payload, source));
-      return;
-    }
-    if (messageType === "guild") {
-      const channelId = qqMeta.channelId ?? msg.chatId;
-      await this.sendWithTokenRetry(() => this.bot?.sendGuildMessage(channelId, payload, source));
-      return;
-    }
-    const userId = qqMeta.userId ?? msg.chatId;
-    await this.sendWithTokenRetry(() => this.bot?.sendPrivateMessage(userId, payload, source));
-  }
-  async handleIncoming(event) {
-    const messageId = event.message_id || event.id || "";
-    if (messageId && this.isDuplicate(messageId)) {
-      return;
-    }
-    if (event.user_id === event.self_id) {
-      return;
-    }
-    const rawEvent = event;
-    const senderId = event.user_id || rawEvent.sender?.member_openid || rawEvent.sender?.user_openid || rawEvent.sender?.user_id || "";
-    if (!senderId) {
-      return;
-    }
-    const content = event.raw_message?.trim() ?? "";
-    const safeContent = content || "[empty message]";
-    let chatId = senderId;
-    let messageType = "private";
-    const qqMeta = {};
-    if (event.message_type === "group") {
-      messageType = "group";
-      const groupId = event.group_id || rawEvent.group_openid || "";
-      chatId = groupId;
-      qqMeta.groupId = groupId;
-      qqMeta.userId = senderId;
-    } else if (event.message_type === "guild") {
-      messageType = "guild";
-      chatId = event.channel_id ?? "";
-      qqMeta.guildId = event.guild_id;
-      qqMeta.channelId = event.channel_id;
-      qqMeta.userId = senderId;
-    } else if (event.sub_type === "direct") {
-      messageType = "direct";
-      chatId = event.guild_id ?? "";
-      qqMeta.guildId = event.guild_id;
-      qqMeta.userId = senderId;
-    } else {
-      qqMeta.userId = senderId;
-    }
-    qqMeta.messageType = messageType;
-    if (!chatId) {
-      return;
-    }
-    if (!this.isAllowed(senderId)) {
-      return;
-    }
-    await this.handleMessage({
-      senderId,
-      chatId,
-      content: safeContent,
-      media: [],
-      metadata: {
-        message_id: messageId,
-        qq: qqMeta
-      }
-    });
-  }
-  isDuplicate(messageId) {
-    if (this.processedSet.has(messageId)) {
-      return true;
-    }
-    this.processedSet.add(messageId);
-    this.processedIds.push(messageId);
-    if (this.processedIds.length > 1e3) {
-      const removed = this.processedIds.splice(0, 500);
-      for (const id of removed) {
-        this.processedSet.delete(id);
-      }
-    }
-    return false;
-  }
-  normalizeContent(content) {
-    const withoutThink = content.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<\/?think>/gi, "");
-    const cleaned = withoutThink.trim();
-    return cleaned || "[empty message]";
-  }
-  async sendWithTokenRetry(send) {
-    try {
-      await send();
-    } catch (error) {
-      if (!this.isTokenExpiredError(error) || !this.bot) {
-        throw error;
-      }
-      try {
-        await this.bot.sessionManager.getAccessToken();
-      } catch (refreshError) {
-        throw refreshError;
-      }
-      await send();
-    }
-  }
-  isTokenExpiredError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return message.includes("code(11244)") || message.toLowerCase().includes("token not exist or expire");
-  }
-};
-
-// src/channels/manager.ts
-var ChannelManager = class {
-  constructor(config, bus, sessionManager) {
-    this.config = config;
-    this.bus = bus;
-    this.sessionManager = sessionManager;
-    this.initChannels();
-  }
-  channels = {};
-  dispatchTask = null;
-  dispatching = false;
-  initChannels() {
-    if (this.config.channels.telegram.enabled) {
-      const channel = new TelegramChannel(
-        this.config.channels.telegram,
-        this.bus,
-        this.config.providers.groq.apiKey,
-        this.sessionManager
-      );
-      this.channels.telegram = channel;
-    }
-    if (this.config.channels.whatsapp.enabled) {
-      const channel = new WhatsAppChannel(this.config.channels.whatsapp, this.bus);
-      this.channels.whatsapp = channel;
-    }
-    if (this.config.channels.discord.enabled) {
-      const channel = new DiscordChannel(this.config.channels.discord, this.bus);
-      this.channels.discord = channel;
-    }
-    if (this.config.channels.feishu.enabled) {
-      const channel = new FeishuChannel(this.config.channels.feishu, this.bus);
-      this.channels.feishu = channel;
-    }
-    if (this.config.channels.mochat.enabled) {
-      const channel = new MochatChannel(this.config.channels.mochat, this.bus);
-      this.channels.mochat = channel;
-    }
-    if (this.config.channels.dingtalk.enabled) {
-      const channel = new DingTalkChannel(this.config.channels.dingtalk, this.bus);
-      this.channels.dingtalk = channel;
-    }
-    if (this.config.channels.email.enabled) {
-      const channel = new EmailChannel(this.config.channels.email, this.bus);
-      this.channels.email = channel;
-    }
-    if (this.config.channels.slack.enabled) {
-      const channel = new SlackChannel(this.config.channels.slack, this.bus);
-      this.channels.slack = channel;
-    }
-    if (this.config.channels.qq.enabled) {
-      const channel = new QQChannel(this.config.channels.qq, this.bus);
-      this.channels.qq = channel;
-    }
-  }
-  async startChannel(name, channel) {
-    try {
-      await channel.start();
-    } catch (err2) {
-      console.error(`Failed to start channel ${name}: ${String(err2)}`);
-    }
-  }
-  async startAll() {
-    if (!Object.keys(this.channels).length) {
-      return;
-    }
-    this.dispatching = true;
-    this.dispatchTask = this.dispatchOutbound();
-    const tasks = Object.entries(this.channels).map(([name, channel]) => this.startChannel(name, channel));
-    await Promise.allSettled(tasks);
-  }
-  async stopAll() {
-    this.dispatching = false;
-    await this.bus.publishOutbound({
-      channel: "__control__",
-      chatId: "",
-      content: "",
-      media: [],
-      metadata: { reason: "shutdown" }
-    });
-    if (this.dispatchTask) {
-      await this.dispatchTask;
-    }
-    const tasks = Object.entries(this.channels).map(async ([name, channel]) => {
-      try {
-        await channel.stop();
-      } catch (err2) {
-        console.error(`Error stopping ${name}: ${String(err2)}`);
-      }
-    });
-    await Promise.allSettled(tasks);
-  }
-  async dispatchOutbound() {
-    while (this.dispatching) {
-      const msg = await this.bus.consumeOutbound();
-      const channel = this.channels[msg.channel];
-      if (!channel) {
-        continue;
-      }
-      try {
-        await channel.send(msg);
-      } catch (err2) {
-        console.error(`Error sending to ${msg.channel}: ${String(err2)}`);
-      }
-    }
-  }
-  getChannel(name) {
-    return this.channels[name];
-  }
-  getStatus() {
-    return Object.fromEntries(
-      Object.entries(this.channels).map(([name, channel]) => [name, { enabled: true, running: channel.isRunning }])
-    );
-  }
-  get enabledChannels() {
-    return Object.keys(this.channels);
-  }
-};
-
-// src/cron/service.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync4 } from "fs";
-import { dirname } from "path";
-import { randomUUID } from "crypto";
-import cronParser from "cron-parser";
-var nowMs = () => Date.now();
-function computeNextRun(schedule, now) {
-  if (schedule.kind === "at") {
-    return schedule.atMs && schedule.atMs > now ? schedule.atMs : null;
-  }
-  if (schedule.kind === "every") {
-    if (!schedule.everyMs || schedule.everyMs <= 0) {
-      return null;
-    }
-    return now + schedule.everyMs;
-  }
-  if (schedule.kind === "cron" && schedule.expr) {
-    try {
-      const interval = cronParser.parseExpression(schedule.expr, { currentDate: new Date(now) });
-      return interval.next().getTime();
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-var CronService = class {
-  constructor(storePath, onJob) {
-    this.storePath = storePath;
-    this.onJob = onJob;
-  }
-  store = null;
-  timer = null;
-  running = false;
-  onJob;
-  loadStore() {
-    if (this.store) {
-      return this.store;
-    }
-    if (existsSync3(this.storePath)) {
-      try {
-        const data = JSON.parse(readFileSync2(this.storePath, "utf-8"));
-        const jobs = (data.jobs ?? []).map((job) => ({
-          id: String(job.id),
-          name: String(job.name),
-          enabled: Boolean(job.enabled ?? true),
-          schedule: job.schedule ?? {},
-          payload: job.payload ?? {},
-          state: job.state ?? {},
-          createdAtMs: Number(job.createdAtMs ?? 0),
-          updatedAtMs: Number(job.updatedAtMs ?? 0),
-          deleteAfterRun: Boolean(job.deleteAfterRun ?? false)
-        }));
-        this.store = { version: data.version ?? 1, jobs };
-      } catch {
-        this.store = { version: 1, jobs: [] };
-      }
-    } else {
-      this.store = { version: 1, jobs: [] };
-    }
-    return this.store;
-  }
-  saveStore() {
-    if (!this.store) {
-      return;
-    }
-    mkdirSync4(dirname(this.storePath), { recursive: true });
-    writeFileSync3(this.storePath, JSON.stringify(this.store, null, 2));
-  }
-  async start() {
-    this.running = true;
-    this.loadStore();
-    this.recomputeNextRuns();
-    this.saveStore();
-    this.armTimer();
-  }
-  stop() {
-    this.running = false;
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-  recomputeNextRuns() {
-    if (!this.store) {
-      return;
-    }
-    const now = nowMs();
-    for (const job of this.store.jobs) {
-      if (job.enabled) {
-        job.state.nextRunAtMs = computeNextRun(job.schedule, now);
-      }
-    }
-  }
-  getNextWakeMs() {
-    if (!this.store) {
-      return null;
-    }
-    const times = this.store.jobs.filter((job) => job.enabled && job.state.nextRunAtMs).map((job) => job.state.nextRunAtMs);
-    if (!times.length) {
-      return null;
-    }
-    return Math.min(...times);
-  }
-  armTimer() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-    }
-    if (!this.running) {
-      return;
-    }
-    const nextWake = this.getNextWakeMs();
-    if (!nextWake) {
-      return;
-    }
-    const delayMs = Math.max(0, nextWake - nowMs());
-    this.timer = setTimeout(() => {
-      void this.onTimer();
-    }, delayMs);
-  }
-  async onTimer() {
-    if (!this.store) {
-      return;
-    }
-    const now = nowMs();
-    const dueJobs = this.store.jobs.filter(
-      (job) => job.enabled && job.state.nextRunAtMs && now >= (job.state.nextRunAtMs ?? 0)
-    );
-    for (const job of dueJobs) {
-      await this.executeJob(job);
-    }
-    this.saveStore();
-    this.armTimer();
-  }
-  async executeJob(job) {
-    const start = nowMs();
-    try {
-      if (this.onJob) {
-        await this.onJob(job);
-      }
-      job.state.lastStatus = "ok";
-      job.state.lastError = null;
-    } catch (err2) {
-      job.state.lastStatus = "error";
-      job.state.lastError = String(err2);
-    }
-    job.state.lastRunAtMs = start;
-    job.updatedAtMs = nowMs();
-    if (job.schedule.kind === "at") {
-      if (job.deleteAfterRun) {
-        if (this.store) {
-          this.store.jobs = this.store.jobs.filter((existing) => existing.id !== job.id);
-        }
-      } else {
-        job.enabled = false;
-        job.state.nextRunAtMs = null;
-      }
-    } else {
-      job.state.nextRunAtMs = computeNextRun(job.schedule, nowMs());
-    }
-  }
-  listJobs(includeDisabled = false) {
-    const store = this.loadStore();
-    const jobs = includeDisabled ? store.jobs : store.jobs.filter((job) => job.enabled);
-    return jobs.sort((a, b) => (a.state.nextRunAtMs ?? Infinity) - (b.state.nextRunAtMs ?? Infinity));
-  }
-  addJob(params) {
-    const store = this.loadStore();
-    const now = nowMs();
-    const job = {
-      id: randomUUID().slice(0, 8),
-      name: params.name,
-      enabled: true,
-      schedule: params.schedule,
-      payload: {
-        kind: "agent_turn",
-        message: params.message,
-        deliver: params.deliver ?? false,
-        channel: params.channel,
-        to: params.to
-      },
-      state: {
-        nextRunAtMs: computeNextRun(params.schedule, now)
-      },
-      createdAtMs: now,
-      updatedAtMs: now,
-      deleteAfterRun: params.deleteAfterRun ?? false
-    };
-    store.jobs.push(job);
-    this.saveStore();
-    this.armTimer();
-    return job;
-  }
-  removeJob(jobId) {
-    const store = this.loadStore();
-    const before = store.jobs.length;
-    store.jobs = store.jobs.filter((job) => job.id !== jobId);
-    const removed = store.jobs.length < before;
-    if (removed) {
-      this.saveStore();
-      this.armTimer();
-    }
-    return removed;
-  }
-  enableJob(jobId, enabled = true) {
-    const store = this.loadStore();
-    for (const job of store.jobs) {
-      if (job.id === jobId) {
-        job.enabled = enabled;
-        job.updatedAtMs = nowMs();
-        job.state.nextRunAtMs = enabled ? computeNextRun(job.schedule, nowMs()) : null;
-        this.saveStore();
-        this.armTimer();
-        return job;
-      }
-    }
-    return null;
-  }
-  async runJob(jobId, force = false) {
-    const store = this.loadStore();
-    for (const job of store.jobs) {
-      if (job.id === jobId) {
-        if (!force && !job.enabled) {
-          return false;
-        }
-        await this.executeJob(job);
-        this.saveStore();
-        this.armTimer();
-        return true;
-      }
-    }
-    return false;
-  }
-  status() {
-    const store = this.loadStore();
-    return {
-      enabled: this.running,
-      jobs: store.jobs.length,
-      nextWakeAtMs: this.getNextWakeMs()
-    };
-  }
-};
-
-// src/heartbeat/service.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-var DEFAULT_HEARTBEAT_INTERVAL_S = 30 * 60;
-var HEARTBEAT_PROMPT = "Read HEARTBEAT.md in your workspace (if it exists).\nFollow any instructions or tasks listed there.\nIf nothing needs attention, reply with just: HEARTBEAT_OK";
-var HEARTBEAT_OK_TOKEN = "HEARTBEAT_OK";
-function isHeartbeatEmpty(content) {
-  if (!content) {
-    return true;
-  }
-  const skipPatterns = /* @__PURE__ */ new Set(["- [ ]", "* [ ]", "- [x]", "* [x]"]);
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("<!--") || skipPatterns.has(trimmed)) {
-      continue;
-    }
-    return false;
-  }
-  return true;
-}
-var HeartbeatService = class {
-  constructor(workspace, onHeartbeat, intervalS = DEFAULT_HEARTBEAT_INTERVAL_S, enabled = true) {
-    this.workspace = workspace;
-    this.onHeartbeat = onHeartbeat;
-    this.intervalS = intervalS;
-    this.enabled = enabled;
-  }
-  running = false;
-  timer = null;
-  get heartbeatFile() {
-    return join4(this.workspace, "HEARTBEAT.md");
-  }
-  readHeartbeatFile() {
-    if (existsSync4(this.heartbeatFile)) {
-      try {
-        return readFileSync3(this.heartbeatFile, "utf-8");
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-  async start() {
-    if (!this.enabled) {
-      return;
-    }
-    this.running = true;
-    this.timer = setInterval(() => {
-      void this.tick();
-    }, this.intervalS * 1e3);
-  }
-  stop() {
-    this.running = false;
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-  async tick() {
-    if (!this.running) {
-      return;
-    }
-    const content = this.readHeartbeatFile();
-    if (isHeartbeatEmpty(content)) {
-      return;
-    }
-    if (this.onHeartbeat) {
-      const response = await this.onHeartbeat(HEARTBEAT_PROMPT);
-      if (response.toUpperCase().replace(/_/g, "").includes(HEARTBEAT_OK_TOKEN.replace(/_/g, ""))) {
-        return;
-      }
-    }
-  }
-  async triggerNow() {
-    if (!this.onHeartbeat) {
-      return null;
-    }
-    return this.onHeartbeat(HEARTBEAT_PROMPT);
-  }
-};
-
-// src/ui/server.ts
-import { Hono as Hono2 } from "hono";
-import { cors } from "hono/cors";
-import { serve } from "@hono/node-server";
-import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { readFile, stat } from "fs/promises";
-import { join as join5 } from "path";
-
-// src/ui/router.ts
-import { Hono } from "hono";
-
-// src/ui/config.ts
-var MASK_MIN_LENGTH = 8;
-function maskApiKey(value) {
-  if (!value) {
-    return { apiKeySet: false };
-  }
-  if (value.length < MASK_MIN_LENGTH) {
-    return { apiKeySet: true, apiKeyMasked: "****" };
-  }
-  return {
-    apiKeySet: true,
-    apiKeyMasked: `${value.slice(0, 2)}****${value.slice(-4)}`
-  };
-}
-function toProviderView(provider) {
-  const masked = maskApiKey(provider.apiKey);
-  return {
-    apiKeySet: masked.apiKeySet,
-    apiKeyMasked: masked.apiKeyMasked,
-    apiBase: provider.apiBase ?? null,
-    extraHeaders: provider.extraHeaders ?? null
-  };
-}
-function buildConfigView(config) {
-  const providers = {};
-  for (const [name, provider] of Object.entries(config.providers)) {
-    providers[name] = toProviderView(provider);
-  }
-  return {
-    agents: config.agents,
-    providers,
-    channels: config.channels,
-    tools: config.tools,
-    gateway: config.gateway,
-    ui: config.ui
-  };
-}
-function buildConfigMeta(config) {
-  const providers = PROVIDERS.map((spec) => ({
-    name: spec.name,
-    displayName: spec.displayName,
-    keywords: spec.keywords,
-    envKey: spec.envKey,
-    isGateway: spec.isGateway,
-    isLocal: spec.isLocal,
-    defaultApiBase: spec.defaultApiBase
-  }));
-  const channels2 = Object.keys(config.channels).map((name) => ({
-    name,
-    displayName: name,
-    enabled: Boolean(config.channels[name]?.enabled)
-  }));
-  return { providers, channels: channels2 };
-}
-function loadConfigOrDefault(configPath) {
-  return loadConfig(configPath);
-}
-function updateModel(configPath, model) {
-  const config = loadConfigOrDefault(configPath);
-  config.agents.defaults.model = model;
-  const next = ConfigSchema.parse(config);
-  saveConfig(next, configPath);
-  return buildConfigView(next);
-}
-function updateProvider(configPath, providerName, patch) {
-  const config = loadConfigOrDefault(configPath);
-  const provider = config.providers[providerName];
-  if (!provider) {
-    return null;
-  }
-  if (Object.prototype.hasOwnProperty.call(patch, "apiKey")) {
-    provider.apiKey = patch.apiKey ?? "";
-  }
-  if (Object.prototype.hasOwnProperty.call(patch, "apiBase")) {
-    provider.apiBase = patch.apiBase ?? null;
-  }
-  if (Object.prototype.hasOwnProperty.call(patch, "extraHeaders")) {
-    provider.extraHeaders = patch.extraHeaders ?? null;
-  }
-  const next = ConfigSchema.parse(config);
-  saveConfig(next, configPath);
-  const updated = next.providers[providerName];
-  return toProviderView(updated);
-}
-function updateChannel(configPath, channelName, patch) {
-  const config = loadConfigOrDefault(configPath);
-  const channel = config.channels[channelName];
-  if (!channel) {
-    return null;
-  }
-  config.channels[channelName] = { ...channel, ...patch };
-  const next = ConfigSchema.parse(config);
-  saveConfig(next, configPath);
-  return next.channels[channelName];
-}
-function updateUi(configPath, patch) {
-  const config = loadConfigOrDefault(configPath);
-  config.ui = { ...config.ui, ...patch };
-  const next = ConfigSchema.parse(config);
-  saveConfig(next, configPath);
-  return next.ui;
-}
-
-// src/channels/feishu-probe.ts
-import * as Lark2 from "@larksuiteoapi/node-sdk";
-var isRecord = (value) => typeof value === "object" && value !== null;
-async function probeFeishu(appId, appSecret) {
-  if (!appId || !appSecret) {
-    return { ok: false, error: "missing credentials (appId, appSecret)" };
-  }
-  try {
-    const client = new Lark2.Client({ appId, appSecret });
-    const response = await client.request({
-      method: "GET",
-      url: "/open-apis/bot/v3/info",
-      data: {}
-    });
-    if (!isRecord(response)) {
-      return {
-        ok: false,
-        appId,
-        error: "API error: invalid response"
-      };
-    }
-    const code = typeof response.code === "number" ? response.code : null;
-    if (code !== 0) {
-      const msg = typeof response.msg === "string" ? response.msg : void 0;
-      return {
-        ok: false,
-        appId,
-        error: `API error: ${msg || `code ${code ?? "unknown"}`}`
-      };
-    }
-    const botFromResponse = isRecord(response.bot) ? response.bot : void 0;
-    const data = isRecord(response.data) ? response.data : void 0;
-    const botFromData = data && isRecord(data.bot) ? data.bot : void 0;
-    const bot = botFromResponse ?? botFromData;
-    const botName = bot && typeof bot.bot_name === "string" ? bot.bot_name : void 0;
-    const botOpenId = bot && typeof bot.open_id === "string" ? bot.open_id : void 0;
-    return {
-      ok: true,
-      appId,
-      botName,
-      botOpenId
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      appId,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-
-// src/ui/router.ts
-function ok(data) {
-  return { ok: true, data };
-}
-function err(code, message, details) {
-  return { ok: false, error: { code, message, details } };
-}
-async function readJson(req) {
-  try {
-    const data = await req.json();
-    return { ok: true, data };
-  } catch {
-    return { ok: false };
-  }
-}
-function createUiRouter(options) {
-  const app = new Hono();
-  app.notFound((c) => c.json(err("NOT_FOUND", "endpoint not found"), 404));
-  app.get("/api/health", (c) => c.json(ok({ status: "ok" })));
-  app.get("/api/config", (c) => {
-    const config = loadConfigOrDefault(options.configPath);
-    return c.json(ok(buildConfigView(config)));
-  });
-  app.get("/api/config/meta", (c) => {
-    const config = loadConfigOrDefault(options.configPath);
-    return c.json(ok(buildConfigMeta(config)));
-  });
-  app.put("/api/config/model", async (c) => {
-    const body = await readJson(c.req.raw);
-    if (!body.ok || !body.data.model) {
-      return c.json(err("INVALID_BODY", "model is required"), 400);
-    }
-    const view = updateModel(options.configPath, body.data.model);
-    options.publish({ type: "config.updated", payload: { path: "agents.defaults.model" } });
-    return c.json(ok({ model: view.agents.defaults.model }));
-  });
-  app.put("/api/config/providers/:provider", async (c) => {
-    const provider = c.req.param("provider");
-    const body = await readJson(c.req.raw);
-    if (!body.ok) {
-      return c.json(err("INVALID_BODY", "invalid json body"), 400);
-    }
-    const result = updateProvider(options.configPath, provider, body.data);
-    if (!result) {
-      return c.json(err("NOT_FOUND", `unknown provider: ${provider}`), 404);
-    }
-    options.publish({ type: "config.updated", payload: { path: `providers.${provider}` } });
-    return c.json(ok(result));
-  });
-  app.put("/api/config/channels/:channel", async (c) => {
-    const channel = c.req.param("channel");
-    const body = await readJson(c.req.raw);
-    if (!body.ok) {
-      return c.json(err("INVALID_BODY", "invalid json body"), 400);
-    }
-    const result = updateChannel(options.configPath, channel, body.data);
-    if (!result) {
-      return c.json(err("NOT_FOUND", `unknown channel: ${channel}`), 404);
-    }
-    options.publish({ type: "config.updated", payload: { path: `channels.${channel}` } });
-    return c.json(ok(result));
-  });
-  app.post("/api/channels/feishu/probe", async (c) => {
-    const config = loadConfigOrDefault(options.configPath);
-    const feishu = config.channels.feishu;
-    if (!feishu?.appId || !feishu?.appSecret) {
-      return c.json(err("MISSING_CREDENTIALS", "Feishu appId/appSecret not configured"), 400);
-    }
-    const result = await probeFeishu(String(feishu.appId), String(feishu.appSecret));
-    if (!result.ok) {
-      return c.json(err("PROBE_FAILED", result.error), 400);
-    }
-    return c.json(
-      ok({
-        appId: result.appId,
-        botName: result.botName ?? null,
-        botOpenId: result.botOpenId ?? null
-      })
-    );
-  });
-  app.put("/api/config/ui", async (c) => {
-    const body = await readJson(c.req.raw);
-    if (!body.ok) {
-      return c.json(err("INVALID_BODY", "invalid json body"), 400);
-    }
-    const result = updateUi(options.configPath, body.data);
-    options.publish({ type: "config.updated", payload: { path: "ui" } });
-    return c.json(ok(result));
-  });
-  app.post("/api/config/reload", async (c) => {
-    options.publish({ type: "config.reload.started" });
-    try {
-      await options.onReload?.();
-    } catch (error) {
-      options.publish({
-        type: "error",
-        payload: { message: "reload failed", code: "RELOAD_FAILED" }
-      });
-      return c.json(err("RELOAD_FAILED", "reload failed"), 500);
-    }
-    options.publish({ type: "config.reload.finished" });
-    return c.json(ok({ status: "ok" }));
-  });
-  return app;
-}
-
-// src/ui/server.ts
-import { serveStatic } from "hono/serve-static";
-var DEFAULT_CORS_ORIGINS = (origin) => {
-  if (!origin) {
-    return void 0;
-  }
-  if (origin.startsWith("http://localhost:") || origin.startsWith("http://127.0.0.1:")) {
-    return origin;
-  }
-  return void 0;
-};
-function startUiServer(options) {
-  const app = new Hono2();
-  const origin = options.corsOrigins ?? DEFAULT_CORS_ORIGINS;
-  app.use("/api/*", cors({ origin }));
-  const clients = /* @__PURE__ */ new Set();
-  const publish = (event) => {
-    const payload = JSON.stringify(event);
-    for (const client of clients) {
-      if (client.readyState === WebSocket2.OPEN) {
-        client.send(payload);
-      }
-    }
-  };
-  app.route(
-    "/",
-    createUiRouter({
-      configPath: options.configPath,
-      publish,
-      onReload: options.onReload
-    })
-  );
-  const staticDir = options.staticDir;
-  if (staticDir && existsSync5(join5(staticDir, "index.html"))) {
-    const indexHtml = readFileSync4(join5(staticDir, "index.html"), "utf-8");
-    app.use(
-      "/*",
-      serveStatic({
-        root: staticDir,
-        join: join5,
-        getContent: async (path) => {
-          try {
-            return await readFile(path);
-          } catch {
-            return null;
-          }
-        },
-        isDir: async (path) => {
-          try {
-            return (await stat(path)).isDirectory();
-          } catch {
-            return false;
-          }
-        }
-      })
-    );
-    app.get("*", (c) => {
-      const path = c.req.path;
-      if (path.startsWith("/api") || path.startsWith("/ws")) {
-        return c.notFound();
-      }
-      return c.html(indexHtml);
-    });
-  }
-  const server = serve({
-    fetch: app.fetch,
-    port: options.port,
-    hostname: options.host
-  });
-  const wss = new WebSocketServer({
-    server,
-    path: "/ws"
-  });
-  wss.on("connection", (socket) => {
-    clients.add(socket);
-    socket.on("close", () => clients.delete(socket));
-  });
-  return {
-    host: options.host,
-    port: options.port,
-    publish,
-    close: () => new Promise((resolve2) => {
-      wss.close(() => {
-        server.close(() => resolve2());
-      });
-    })
-  };
-}
 
 // src/cli/index.ts
+import { Command } from "commander";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  cpSync,
+  rmSync,
+  openSync,
+  closeSync
+} from "fs";
+import { join, resolve } from "path";
+import { spawn, spawnSync } from "child_process";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+import { createServer } from "net";
+import chokidar from "chokidar";
+import {
+  loadConfig,
+  saveConfig,
+  getConfigPath,
+  getDataDir,
+  ConfigSchema,
+  getApiBase,
+  getProvider,
+  getProviderName,
+  buildReloadPlan,
+  diffConfigPaths,
+  getWorkspacePath,
+  MessageBus,
+  AgentLoop,
+  LiteLLMProvider,
+  ChannelManager,
+  SessionManager,
+  CronService,
+  HeartbeatService,
+  PROVIDERS,
+  APP_NAME,
+  APP_TAGLINE
+} from "nextclaw-core";
+import { startUiServer } from "nextclaw-server";
 var LOGO = "\u{1F916}";
 var EXIT_COMMANDS = /* @__PURE__ */ new Set(["exit", "quit", "/exit", "/quit", ":q"]);
 var VERSION = getPackageVersion();
@@ -3323,7 +49,7 @@ var program = new Command();
 program.name(APP_NAME).description(`${LOGO} ${APP_NAME} - ${APP_TAGLINE}`).version(VERSION, "-v, --version", "show version");
 program.command("onboard").description(`Initialize ${APP_NAME} configuration and workspace`).action(() => {
   const configPath = getConfigPath();
-  if (existsSync6(configPath)) {
+  if (existsSync(configPath)) {
     console.log(`Config already exists at ${configPath}`);
   }
   const config = ConfigSchema.parse({});
@@ -3474,14 +200,14 @@ program.command("agent").description("Interact with the agent directly").option(
   }
   console.log(`${LOGO} Interactive mode (type exit or Ctrl+C to quit)
 `);
-  const historyFile = join6(getDataDir(), "history", "cli_history");
+  const historyFile = join(getDataDir(), "history", "cli_history");
   const historyDir = resolve(historyFile, "..");
-  mkdirSync5(historyDir, { recursive: true });
-  const history = existsSync6(historyFile) ? readFileSync5(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+  mkdirSync(historyDir, { recursive: true });
+  const history = existsSync(historyFile) ? readFileSync(historyFile, "utf-8").split("\n").filter(Boolean) : [];
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   rl.on("close", () => {
     const merged = history.concat(rl.history ?? []);
-    writeFileSync4(historyFile, merged.join("\n"));
+    writeFileSync(historyFile, merged.join("\n"));
     process.exit(0);
   });
   let running = true;
@@ -3523,7 +249,7 @@ channels.command("login").description("Link device via QR code").action(() => {
 });
 var cron = program.command("cron").description("Manage scheduled tasks");
 cron.command("list").option("-a, --all", "Include disabled jobs").action((opts) => {
-  const storePath = join6(getDataDir(), "cron", "jobs.json");
+  const storePath = join(getDataDir(), "cron", "jobs.json");
   const service = new CronService(storePath);
   const jobs = service.listJobs(Boolean(opts.all));
   if (!jobs.length) {
@@ -3543,7 +269,7 @@ cron.command("list").option("-a, --all", "Include disabled jobs").action((opts)
   }
 });
 cron.command("add").requiredOption("-n, --name <name>", "Job name").requiredOption("-m, --message <message>", "Message for agent").option("-e, --every <seconds>", "Run every N seconds").option("-c, --cron <expr>", "Cron expression").option("--at <iso>", "Run once at time (ISO format)").option("-d, --deliver", "Deliver response to channel").option("--to <recipient>", "Recipient for delivery").option("--channel <channel>", "Channel for delivery").action((opts) => {
-  const storePath = join6(getDataDir(), "cron", "jobs.json");
+  const storePath = join(getDataDir(), "cron", "jobs.json");
   const service = new CronService(storePath);
   let schedule = null;
   if (opts.every) {
@@ -3568,7 +294,7 @@ cron.command("add").requiredOption("-n, --name <name>", "Job name").requiredOpti
   console.log(`\u2713 Added job '${job.name}' (${job.id})`);
 });
 cron.command("remove <jobId>").action((jobId) => {
-  const storePath = join6(getDataDir(), "cron", "jobs.json");
+  const storePath = join(getDataDir(), "cron", "jobs.json");
   const service = new CronService(storePath);
   if (service.removeJob(jobId)) {
     console.log(`\u2713 Removed job ${jobId}`);
@@ -3577,7 +303,7 @@ cron.command("remove <jobId>").action((jobId) => {
   }
 });
 cron.command("enable <jobId>").option("--disable", "Disable instead of enable").action((jobId, opts) => {
-  const storePath = join6(getDataDir(), "cron", "jobs.json");
+  const storePath = join(getDataDir(), "cron", "jobs.json");
   const service = new CronService(storePath);
   const job = service.enableJob(jobId, !opts.disable);
   if (job) {
@@ -3587,10 +313,10 @@ cron.command("enable <jobId>").option("--disable", "Disable instead of enable").
   }
 });
 cron.command("run <jobId>").option("-f, --force", "Run even if disabled").action(async (jobId, opts) => {
-  const storePath = join6(getDataDir(), "cron", "jobs.json");
+  const storePath = join(getDataDir(), "cron", "jobs.json");
   const service = new CronService(storePath);
-  const ok2 = await service.runJob(jobId, Boolean(opts.force));
-  console.log(ok2 ? "\u2713 Job executed" : `Failed to run job ${jobId}`);
+  const ok = await service.runJob(jobId, Boolean(opts.force));
+  console.log(ok ? "\u2713 Job executed" : `Failed to run job ${jobId}`);
 });
 program.command("status").description(`Show ${APP_NAME} status`).action(() => {
   const configPath = getConfigPath();
@@ -3598,8 +324,8 @@ program.command("status").description(`Show ${APP_NAME} status`).action(() => {
   const workspace = getWorkspacePath(config.agents.defaults.workspace);
   console.log(`${LOGO} ${APP_NAME} Status
 `);
-  console.log(`Config: ${configPath} ${existsSync6(configPath) ? "\u2713" : "\u2717"}`);
-  console.log(`Workspace: ${workspace} ${existsSync6(workspace) ? "\u2713" : "\u2717"}`);
+  console.log(`Config: ${configPath} ${existsSync(configPath) ? "\u2713" : "\u2717"}`);
+  console.log(`Workspace: ${workspace} ${existsSync(workspace) ? "\u2713" : "\u2717"}`);
   console.log(`Model: ${config.agents.defaults.model}`);
   for (const spec of PROVIDERS) {
     const provider = config.providers[spec.name];
@@ -3619,7 +345,7 @@ async function startGateway(options = {}) {
   const bus = new MessageBus();
   const provider = options.allowMissingProvider === true ? makeProvider(config, { allowMissing: true }) : makeProvider(config);
   const sessionManager = new SessionManager(getWorkspacePath(config.agents.defaults.workspace));
-  const cronStorePath = join6(getDataDir(), "cron", "jobs.json");
+  const cronStorePath = join(getDataDir(), "cron", "jobs.json");
   const cron2 = new CronService(cronStorePath);
   const uiConfig = resolveUiConfig(config, options.uiOverrides);
   const uiStaticDir = options.uiStaticDir === void 0 ? resolveUiStaticDir() : options.uiStaticDir;
@@ -3810,8 +536,8 @@ async function findAvailablePort(port, host, attempts = 20) {
   const basePort = Number.isFinite(port) ? port : 0;
   let candidate = basePort;
   for (let i = 0; i < attempts; i += 1) {
-    const ok2 = await isPortAvailable(candidate, host);
-    if (ok2) {
+    const ok = await isPortAvailable(candidate, host);
+    if (ok) {
       return candidate;
     }
     candidate += 1;
@@ -3827,8 +553,8 @@ async function isPortAvailable(port, host) {
     hostsToCheck.push("127.0.0.1");
   }
   for (const hostToCheck of hostsToCheck) {
-    const ok2 = await canBindPort(port, hostToCheck);
-    if (!ok2) {
+    const ok = await canBindPort(port, hostToCheck);
+    if (!ok) {
       return false;
     }
   }
@@ -3900,7 +626,7 @@ async function startService(options) {
   }
   const logPath = resolveServiceLogPath();
   const logDir = resolve(logPath, "..");
-  mkdirSync5(logDir, { recursive: true });
+  mkdirSync(logDir, { recursive: true });
   const logFd = openSync(logPath, "a");
   const serveArgs = buildServeArgs({
     uiHost: uiConfig.host,
@@ -3980,11 +706,11 @@ function buildServeArgs(options) {
 }
 function readServiceState() {
   const path = resolveServiceStatePath();
-  if (!existsSync6(path)) {
+  if (!existsSync(path)) {
     return null;
   }
   try {
-    const raw = readFileSync5(path, "utf-8");
+    const raw = readFileSync(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -3992,12 +718,12 @@ function readServiceState() {
 }
 function writeServiceState(state) {
   const path = resolveServiceStatePath();
-  mkdirSync5(resolve(path, ".."), { recursive: true });
-  writeFileSync4(path, JSON.stringify(state, null, 2));
+  mkdirSync(resolve(path, ".."), { recursive: true });
+  writeFileSync(path, JSON.stringify(state, null, 2));
 }
 function clearServiceState() {
   const path = resolveServiceStatePath();
-  if (existsSync6(path)) {
+  if (existsSync(path)) {
     rmSync(path, { force: true });
   }
 }
@@ -4033,18 +759,18 @@ function resolveUiStaticDir() {
   }
   const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
   const pkgRoot = resolve(cliDir, "..", "..");
-  candidates.push(join6(pkgRoot, "ui-dist"));
-  candidates.push(join6(pkgRoot, "ui"));
-  candidates.push(join6(pkgRoot, "..", "ui-dist"));
-  candidates.push(join6(pkgRoot, "..", "ui"));
+  candidates.push(join(pkgRoot, "ui-dist"));
+  candidates.push(join(pkgRoot, "ui"));
+  candidates.push(join(pkgRoot, "..", "ui-dist"));
+  candidates.push(join(pkgRoot, "..", "ui"));
   const cwd = process.cwd();
-  candidates.push(join6(cwd, "packages", "nextclaw-ui", "dist"));
-  candidates.push(join6(cwd, "nextclaw-ui", "dist"));
-  candidates.push(join6(pkgRoot, "..", "nextclaw-ui", "dist"));
-  candidates.push(join6(pkgRoot, "..", "..", "packages", "nextclaw-ui", "dist"));
-  candidates.push(join6(pkgRoot, "..", "..", "nextclaw-ui", "dist"));
+  candidates.push(join(cwd, "packages", "nextclaw-ui", "dist"));
+  candidates.push(join(cwd, "nextclaw-ui", "dist"));
+  candidates.push(join(pkgRoot, "..", "nextclaw-ui", "dist"));
+  candidates.push(join(pkgRoot, "..", "..", "packages", "nextclaw-ui", "dist"));
+  candidates.push(join(pkgRoot, "..", "..", "nextclaw-ui", "dist"));
   for (const dir of candidates) {
-    if (existsSync6(join6(dir, "index.html"))) {
+    if (existsSync(join(dir, "index.html"))) {
       return dir;
     }
   }
@@ -4108,22 +834,22 @@ I am ${APP_NAME}, a lightweight AI assistant.
     "USER.md": "# User\n\nInformation about the user goes here.\n\n## Preferences\n\n- Communication style: (casual/formal)\n- Timezone: (your timezone)\n- Language: (your preferred language)\n"
   };
   for (const [filename, content] of Object.entries(templates)) {
-    const filePath = join6(workspace, filename);
-    if (!existsSync6(filePath)) {
-      writeFileSync4(filePath, content);
+    const filePath = join(workspace, filename);
+    if (!existsSync(filePath)) {
+      writeFileSync(filePath, content);
     }
   }
-  const memoryDir = join6(workspace, "memory");
-  mkdirSync5(memoryDir, { recursive: true });
-  const memoryFile = join6(memoryDir, "MEMORY.md");
-  if (!existsSync6(memoryFile)) {
-    writeFileSync4(
+  const memoryDir = join(workspace, "memory");
+  mkdirSync(memoryDir, { recursive: true });
+  const memoryFile = join(memoryDir, "MEMORY.md");
+  if (!existsSync(memoryFile)) {
+    writeFileSync(
       memoryFile,
       "# Long-term Memory\n\nThis file stores important information that should persist across sessions.\n\n## User Information\n\n(Important facts about the user)\n\n## Preferences\n\n(User preferences learned over time)\n\n## Important Notes\n\n(Things to remember)\n"
     );
   }
-  const skillsDir = join6(workspace, "skills");
-  mkdirSync5(skillsDir, { recursive: true });
+  const skillsDir = join(workspace, "skills");
+  mkdirSync(skillsDir, { recursive: true });
 }
 function printAgentResponse(response) {
   console.log("\n" + response + "\n");
@@ -4136,8 +862,8 @@ async function prompt(rl, question) {
   });
 }
 function getBridgeDir() {
-  const userBridge = join6(getDataDir(), "bridge");
-  if (existsSync6(join6(userBridge, "dist", "index.js"))) {
+  const userBridge = join(getDataDir(), "bridge");
+  if (existsSync(join(userBridge, "dist", "index.js"))) {
     return userBridge;
   }
   if (!which("npm")) {
@@ -4146,12 +872,12 @@ function getBridgeDir() {
   }
   const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
   const pkgRoot = resolve(cliDir, "..", "..");
-  const pkgBridge = join6(pkgRoot, "bridge");
-  const srcBridge = join6(pkgRoot, "..", "..", "bridge");
+  const pkgBridge = join(pkgRoot, "bridge");
+  const srcBridge = join(pkgRoot, "..", "..", "bridge");
   let source = null;
-  if (existsSync6(join6(pkgBridge, "package.json"))) {
+  if (existsSync(join(pkgBridge, "package.json"))) {
     source = pkgBridge;
-  } else if (existsSync6(join6(srcBridge, "package.json"))) {
+  } else if (existsSync(join(srcBridge, "package.json"))) {
     source = srcBridge;
   }
   if (!source) {
@@ -4159,8 +885,8 @@ function getBridgeDir() {
     process.exit(1);
   }
   console.log(`${LOGO} Setting up bridge...`);
-  mkdirSync5(resolve(userBridge, ".."), { recursive: true });
-  if (existsSync6(userBridge)) {
+  mkdirSync(resolve(userBridge, ".."), { recursive: true });
+  if (existsSync(userBridge)) {
     rmSync(userBridge, { recursive: true, force: true });
   }
   cpSync(source, userBridge, {
@@ -4190,7 +916,7 @@ function getPackageVersion() {
   try {
     const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
     const pkgPath = resolve(cliDir, "..", "..", "package.json");
-    const raw = readFileSync5(pkgPath, "utf-8");
+    const raw = readFileSync(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" ? parsed.version : "0.0.0";
   } catch {
@@ -4200,8 +926,8 @@ function getPackageVersion() {
 function which(binary) {
   const paths = (process.env.PATH ?? "").split(":");
   for (const dir of paths) {
-    const full = join6(dir, binary);
-    if (existsSync6(full)) {
+    const full = join(dir, binary);
+    if (existsSync(full)) {
       return true;
     }
   }
@@ -4251,15 +977,15 @@ function resolveUiFrontendDir() {
     candidates.push(envDir);
   }
   const cwd = process.cwd();
-  candidates.push(join6(cwd, "packages", "nextclaw-ui"));
-  candidates.push(join6(cwd, "nextclaw-ui"));
+  candidates.push(join(cwd, "packages", "nextclaw-ui"));
+  candidates.push(join(cwd, "nextclaw-ui"));
   const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
   const pkgRoot = resolve(cliDir, "..", "..");
-  candidates.push(join6(pkgRoot, "..", "nextclaw-ui"));
-  candidates.push(join6(pkgRoot, "..", "..", "packages", "nextclaw-ui"));
-  candidates.push(join6(pkgRoot, "..", "..", "nextclaw-ui"));
+  candidates.push(join(pkgRoot, "..", "nextclaw-ui"));
+  candidates.push(join(pkgRoot, "..", "..", "packages", "nextclaw-ui"));
+  candidates.push(join(pkgRoot, "..", "..", "nextclaw-ui"));
   for (const dir of candidates) {
-    if (existsSync6(join6(dir, "package.json"))) {
+    if (existsSync(join(dir, "package.json"))) {
       return dir;
     }
   }