nextclaw 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,3125 @@
+#!/usr/bin/env node
+import {
+  AgentLoop,
+  ConfigSchema,
+  LiteLLMProvider,
+  PROVIDERS,
+  SessionManager,
+  getApiBase,
+  getConfigPath,
+  getDataDir,
+  getDataPath,
+  getProvider,
+  getProviderName,
+  getWorkspacePath,
+  loadConfig,
+  saveConfig
+} from "../chunk-RTVGGPPW.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, cpSync, rmSync } from "fs";
+import { join as join5, resolve } from "path";
+import { spawnSync } from "child_process";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+
+// 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 (err) {
+          console.error(`Error dispatching to ${msg.channel}: ${String(err)}`);
+        }
+      }
+    }
+  }
+  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 nextclaw.
+
+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>nextclaw commands</b>\n\n/start \u2014 Start the bot\n/reset \u2014 Reset conversation history\n/help \u2014 Show this help message\n\nJust 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 ok = await this.subscribeSessions(sessions);
+    ok = await this.subscribePanels(panels) && ok;
+    if (this.autoDiscoverSessions || this.autoDiscoverPanels) {
+      await this.refreshTargets(true);
+    }
+    return ok;
+  }
+  async subscribeSessions(sessionIds) {
+    if (!sessionIds.length) {
+      return true;
+    }
+    for (const sid of sessionIds) {
+      if (!(sid in this.sessionCursor)) {
+        this.coldSessions.add(sid);
+      }
+    }
+    const ack = await this.socketCall("com.claw.im.subscribeSessions", {
+      sessionIds,
+      cursors: this.sessionCursor,
+      limit: this.config.watchLimit
+    });
+    if (!ack.result) {
+      return false;
+    }
+    const data = ack.data;
+    let items = [];
+    if (Array.isArray(data)) {
+      items = data.filter((item) => typeof item === "object" && item !== null);
+    } else if (data && typeof data === "object") {
+      const sessions = data.sessions;
+      if (Array.isArray(sessions)) {
+        items = sessions.filter((item) => typeof item === "object" && item !== null);
+      } else if (data.sessionId) {
+        items = [data];
+      }
+    }
+    for (const payload of items) {
+      await this.handleWatchPayload(payload, "session");
+    }
+    return true;
+  }
+  async subscribePanels(panelIds) {
+    if (!this.autoDiscoverPanels && !panelIds.length) {
+      return true;
+    }
+    const ack = await this.socketCall("com.claw.im.subscribePanels", { panelIds });
+    if (!ack.result) {
+      return false;
+    }
+    return true;
+  }
+  async socketCall(eventName, payload) {
+    if (!this.socket) {
+      return { result: false, message: "socket not connected" };
+    }
+    return new Promise((resolve2) => {
+      this.socket?.timeout(1e4).emit(eventName, payload, (err, response) => {
+        if (err) {
+          resolve2({ result: false, message: String(err) });
+          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: "Nextclaw 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) ?? "nextclaw reply";
+    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 { createOpenAPI, createWebsocket, AvailableIntentsEventsEnum } from "qq-bot-sdk";
+var QQChannel = class extends BaseChannel {
+  name = "qq";
+  client = null;
+  ws = 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/secret not configured");
+    }
+    const wsConfig = {
+      appID: this.config.appId,
+      token: this.config.secret,
+      intents: [AvailableIntentsEventsEnum.GROUP_AND_C2C_EVENT]
+    };
+    this.client = createOpenAPI(wsConfig);
+    this.ws = createWebsocket(wsConfig);
+    this.ws.on(AvailableIntentsEventsEnum.GROUP_AND_C2C_EVENT, async (data) => {
+      await this.handleIncoming(data);
+    });
+  }
+  async stop() {
+    this.running = false;
+    if (this.ws) {
+      this.ws.disconnect();
+      this.ws = null;
+    }
+  }
+  async send(msg) {
+    if (!this.client) {
+      return;
+    }
+    await this.client.c2cApi.postMessage(msg.chatId, {
+      content: msg.content ?? "",
+      msg_type: 0
+    });
+  }
+  async handleIncoming(data) {
+    const payload = data.msg ?? {};
+    const messageId = payload.id ?? "";
+    if (messageId && this.isDuplicate(messageId)) {
+      return;
+    }
+    const author = payload.author ?? {};
+    const senderId = author.user_openid || author.id || "";
+    const content = payload.content?.trim() ?? "";
+    if (!senderId || !content) {
+      return;
+    }
+    if (!this.isAllowed(senderId)) {
+      return;
+    }
+    await this.handleMessage({
+      senderId,
+      chatId: senderId,
+      content,
+      media: [],
+      metadata: {
+        message_id: messageId
+      }
+    });
+  }
+  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;
+  }
+};
+
+// 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 (err) {
+      console.error(`Failed to start channel ${name}: ${String(err)}`);
+    }
+  }
+  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;
+    if (this.dispatchTask) {
+      await this.dispatchTask;
+    }
+    const tasks = Object.entries(this.channels).map(async ([name, channel]) => {
+      try {
+        await channel.stop();
+      } catch (err) {
+        console.error(`Error stopping ${name}: ${String(err)}`);
+      }
+    });
+    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 (err) {
+        console.error(`Error sending to ${msg.channel}: ${String(err)}`);
+      }
+    }
+  }
+  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 (err) {
+      job.state.lastStatus = "error";
+      job.state.lastError = String(err);
+    }
+    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/cli/index.ts
+var LOGO = "\u{1F916}";
+var EXIT_COMMANDS = /* @__PURE__ */ new Set(["exit", "quit", "/exit", "/quit", ":q"]);
+var VERSION = getPackageVersion();
+var program = new Command();
+program.name("nextclaw").description(`${LOGO} nextclaw - Personal AI Assistant`).version(VERSION, "-v, --version", "show version");
+program.command("onboard").description("Initialize nextclaw configuration and workspace").action(() => {
+  const configPath = getConfigPath();
+  if (existsSync5(configPath)) {
+    console.log(`Config already exists at ${configPath}`);
+  }
+  const config = ConfigSchema.parse({});
+  saveConfig(config);
+  console.log(`\u2713 Created config at ${configPath}`);
+  const workspace = getWorkspacePath();
+  console.log(`\u2713 Created workspace at ${workspace}`);
+  createWorkspaceTemplates(workspace);
+  console.log(`
+${LOGO} nextclaw is ready!`);
+  console.log("\nNext steps:");
+  console.log(`  1. Add your API key to ${configPath}`);
+  console.log('  2. Chat: nextclaw agent -m "Hello!"');
+});
+program.command("gateway").description("Start the nextclaw gateway").option("-p, --port <port>", "Gateway port", "18790").option("-v, --verbose", "Verbose output", false).action(async (_opts) => {
+  const config = loadConfig();
+  const bus = new MessageBus();
+  const provider = makeProvider(config);
+  const sessionManager = new SessionManager(getWorkspacePath(config.agents.defaults.workspace));
+  const cronStorePath = join5(getDataDir(), "cron", "jobs.json");
+  const cron2 = new CronService(cronStorePath);
+  const agent = new AgentLoop({
+    bus,
+    provider,
+    workspace: getWorkspacePath(config.agents.defaults.workspace),
+    model: config.agents.defaults.model,
+    maxIterations: config.agents.defaults.maxToolIterations,
+    braveApiKey: config.tools.web.search.apiKey || void 0,
+    execConfig: config.tools.exec,
+    cronService: cron2,
+    restrictToWorkspace: config.tools.restrictToWorkspace,
+    sessionManager
+  });
+  cron2.onJob = async (job) => {
+    const response = await agent.processDirect({
+      content: job.payload.message,
+      sessionKey: `cron:${job.id}`,
+      channel: job.payload.channel ?? "cli",
+      chatId: job.payload.to ?? "direct"
+    });
+    if (job.payload.deliver && job.payload.to) {
+      await bus.publishOutbound({
+        channel: job.payload.channel ?? "cli",
+        chatId: job.payload.to,
+        content: response,
+        media: [],
+        metadata: {}
+      });
+    }
+    return response;
+  };
+  const heartbeat = new HeartbeatService(
+    getWorkspacePath(config.agents.defaults.workspace),
+    async (prompt2) => agent.processDirect({ content: prompt2, sessionKey: "heartbeat" }),
+    30 * 60,
+    true
+  );
+  const channels2 = new ChannelManager(config, bus, sessionManager);
+  if (channels2.enabledChannels.length) {
+    console.log(`\u2713 Channels enabled: ${channels2.enabledChannels.join(", ")}`);
+  } else {
+    console.log("Warning: No channels enabled");
+  }
+  const cronStatus = cron2.status();
+  if (cronStatus.jobs > 0) {
+    console.log(`\u2713 Cron: ${cronStatus.jobs} scheduled jobs`);
+  }
+  console.log("\u2713 Heartbeat: every 30m");
+  await cron2.start();
+  await heartbeat.start();
+  await Promise.allSettled([agent.run(), channels2.startAll()]);
+});
+program.command("agent").description("Interact with the agent directly").option("-m, --message <message>", "Message to send to the agent").option("-s, --session <session>", "Session ID", "cli:default").option("--no-markdown", "Disable Markdown rendering").action(async (opts) => {
+  const config = loadConfig();
+  const bus = new MessageBus();
+  const provider = makeProvider(config);
+  const agentLoop = new AgentLoop({
+    bus,
+    provider,
+    workspace: getWorkspacePath(config.agents.defaults.workspace),
+    braveApiKey: config.tools.web.search.apiKey || void 0,
+    execConfig: config.tools.exec,
+    restrictToWorkspace: config.tools.restrictToWorkspace
+  });
+  if (opts.message) {
+    const response = await agentLoop.processDirect({
+      content: opts.message,
+      sessionKey: opts.session,
+      channel: "cli",
+      chatId: "direct"
+    });
+    printAgentResponse(response);
+    return;
+  }
+  console.log(`${LOGO} Interactive mode (type exit or Ctrl+C to quit)
+`);
+  const historyFile = join5(getDataDir(), "history", "cli_history");
+  const historyDir = resolve(historyFile, "..");
+  mkdirSync5(historyDir, { recursive: true });
+  const history = existsSync5(historyFile) ? readFileSync4(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"));
+    process.exit(0);
+  });
+  let running = true;
+  while (running) {
+    const line = await prompt(rl, "You: ");
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (EXIT_COMMANDS.has(trimmed.toLowerCase())) {
+      rl.close();
+      running = false;
+      break;
+    }
+    const response = await agentLoop.processDirect({ content: trimmed, sessionKey: opts.session });
+    printAgentResponse(response);
+  }
+});
+var channels = program.command("channels").description("Manage channels");
+channels.command("status").description("Show channel status").action(() => {
+  const config = loadConfig();
+  console.log("Channel Status");
+  console.log(`WhatsApp: ${config.channels.whatsapp.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`Discord: ${config.channels.discord.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`Feishu: ${config.channels.feishu.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`Mochat: ${config.channels.mochat.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`Telegram: ${config.channels.telegram.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`Slack: ${config.channels.slack.enabled ? "\u2713" : "\u2717"}`);
+  console.log(`QQ: ${config.channels.qq.enabled ? "\u2713" : "\u2717"}`);
+});
+channels.command("login").description("Link device via QR code").action(() => {
+  const bridgeDir = getBridgeDir();
+  console.log(`${LOGO} Starting bridge...`);
+  console.log("Scan the QR code to connect.\n");
+  const result = spawnSync("npm", ["start"], { cwd: bridgeDir, stdio: "inherit" });
+  if (result.status !== 0) {
+    console.error(`Bridge failed: ${result.status ?? 1}`);
+  }
+});
+var cron = program.command("cron").description("Manage scheduled tasks");
+cron.command("list").option("-a, --all", "Include disabled jobs").action((opts) => {
+  const storePath = join5(getDataDir(), "cron", "jobs.json");
+  const service = new CronService(storePath);
+  const jobs = service.listJobs(Boolean(opts.all));
+  if (!jobs.length) {
+    console.log("No scheduled jobs.");
+    return;
+  }
+  for (const job of jobs) {
+    let schedule = "";
+    if (job.schedule.kind === "every") {
+      schedule = `every ${Math.round((job.schedule.everyMs ?? 0) / 1e3)}s`;
+    } else if (job.schedule.kind === "cron") {
+      schedule = job.schedule.expr ?? "";
+    } else {
+      schedule = job.schedule.atMs ? new Date(job.schedule.atMs).toISOString() : "";
+    }
+    console.log(`${job.id} ${job.name} ${schedule}`);
+  }
+});
+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 = join5(getDataDir(), "cron", "jobs.json");
+  const service = new CronService(storePath);
+  let schedule = null;
+  if (opts.every) {
+    schedule = { kind: "every", everyMs: Number(opts.every) * 1e3 };
+  } else if (opts.cron) {
+    schedule = { kind: "cron", expr: String(opts.cron) };
+  } else if (opts.at) {
+    schedule = { kind: "at", atMs: Date.parse(String(opts.at)) };
+  }
+  if (!schedule) {
+    console.error("Error: Must specify --every, --cron, or --at");
+    return;
+  }
+  const job = service.addJob({
+    name: opts.name,
+    schedule,
+    message: opts.message,
+    deliver: Boolean(opts.deliver),
+    channel: opts.channel,
+    to: opts.to
+  });
+  console.log(`\u2713 Added job '${job.name}' (${job.id})`);
+});
+cron.command("remove <jobId>").action((jobId) => {
+  const storePath = join5(getDataDir(), "cron", "jobs.json");
+  const service = new CronService(storePath);
+  if (service.removeJob(jobId)) {
+    console.log(`\u2713 Removed job ${jobId}`);
+  } else {
+    console.log(`Job ${jobId} not found`);
+  }
+});
+cron.command("enable <jobId>").option("--disable", "Disable instead of enable").action((jobId, opts) => {
+  const storePath = join5(getDataDir(), "cron", "jobs.json");
+  const service = new CronService(storePath);
+  const job = service.enableJob(jobId, !opts.disable);
+  if (job) {
+    console.log(`\u2713 Job '${job.name}' ${opts.disable ? "disabled" : "enabled"}`);
+  } else {
+    console.log(`Job ${jobId} not found`);
+  }
+});
+cron.command("run <jobId>").option("-f, --force", "Run even if disabled").action(async (jobId, opts) => {
+  const storePath = join5(getDataDir(), "cron", "jobs.json");
+  const service = new CronService(storePath);
+  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 nextclaw status").action(() => {
+  const configPath = getConfigPath();
+  const config = loadConfig();
+  const workspace = getWorkspacePath(config.agents.defaults.workspace);
+  console.log(`${LOGO} nextclaw Status
+`);
+  console.log(`Config: ${configPath} ${existsSync5(configPath) ? "\u2713" : "\u2717"}`);
+  console.log(`Workspace: ${workspace} ${existsSync5(workspace) ? "\u2713" : "\u2717"}`);
+  console.log(`Model: ${config.agents.defaults.model}`);
+  for (const spec of PROVIDERS) {
+    const provider = config.providers[spec.name];
+    if (!provider) {
+      continue;
+    }
+    if (spec.isLocal) {
+      console.log(`${spec.displayName ?? spec.name}: ${provider.apiBase ? `\u2713 ${provider.apiBase}` : "not set"}`);
+    } else {
+      console.log(`${spec.displayName ?? spec.name}: ${provider.apiKey ? "\u2713" : "not set"}`);
+    }
+  }
+});
+program.parseAsync(process.argv);
+function makeProvider(config) {
+  const provider = getProvider(config);
+  const model = config.agents.defaults.model;
+  if (!provider?.apiKey && !model.startsWith("bedrock/")) {
+    console.error("Error: No API key configured.");
+    console.error("Set one in ~/.nextclaw/config.json under providers section");
+    process.exit(1);
+  }
+  return new LiteLLMProvider({
+    apiKey: provider?.apiKey ?? null,
+    apiBase: getApiBase(config),
+    defaultModel: model,
+    extraHeaders: provider?.extraHeaders ?? null,
+    providerName: getProviderName(config)
+  });
+}
+function createWorkspaceTemplates(workspace) {
+  const templates = {
+    "AGENTS.md": "# Agent Instructions\n\nYou are a helpful AI assistant. Be concise, accurate, and friendly.\n\n## Guidelines\n\n- Always explain what you're doing before taking actions\n- Ask for clarification when the request is ambiguous\n- Use tools to help accomplish tasks\n- Remember important information in your memory files\n",
+    "SOUL.md": "# Soul\n\nI am nextclaw, a lightweight AI assistant.\n\n## Personality\n\n- Helpful and friendly\n- Concise and to the point\n- Curious and eager to learn\n\n## Values\n\n- Accuracy over speed\n- User privacy and safety\n- Transparency in actions\n",
+    "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 = join5(workspace, filename);
+    if (!existsSync5(filePath)) {
+      writeFileSync4(filePath, content);
+    }
+  }
+  const memoryDir = join5(workspace, "memory");
+  mkdirSync5(memoryDir, { recursive: true });
+  const memoryFile = join5(memoryDir, "MEMORY.md");
+  if (!existsSync5(memoryFile)) {
+    writeFileSync4(
+      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 = join5(workspace, "skills");
+  mkdirSync5(skillsDir, { recursive: true });
+}
+function printAgentResponse(response) {
+  console.log("\n" + response + "\n");
+}
+async function prompt(rl, question) {
+  rl.setPrompt(question);
+  rl.prompt();
+  return new Promise((resolve2) => {
+    rl.once("line", (line) => resolve2(line));
+  });
+}
+function getBridgeDir() {
+  const userBridge = join5(getDataDir(), "bridge");
+  if (existsSync5(join5(userBridge, "dist", "index.js"))) {
+    return userBridge;
+  }
+  if (!which("npm")) {
+    console.error("npm not found. Please install Node.js >= 18.");
+    process.exit(1);
+  }
+  const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
+  const pkgRoot = resolve(cliDir, "..", "..");
+  const pkgBridge = join5(pkgRoot, "bridge");
+  const srcBridge = join5(pkgRoot, "..", "..", "bridge");
+  let source = null;
+  if (existsSync5(join5(pkgBridge, "package.json"))) {
+    source = pkgBridge;
+  } else if (existsSync5(join5(srcBridge, "package.json"))) {
+    source = srcBridge;
+  }
+  if (!source) {
+    console.error("Bridge source not found. Try reinstalling nextclaw.");
+    process.exit(1);
+  }
+  console.log(`${LOGO} Setting up bridge...`);
+  mkdirSync5(resolve(userBridge, ".."), { recursive: true });
+  if (existsSync5(userBridge)) {
+    rmSync(userBridge, { recursive: true, force: true });
+  }
+  cpSync(source, userBridge, {
+    recursive: true,
+    filter: (src) => !src.includes("node_modules") && !src.includes("dist")
+  });
+  const install = spawnSync("npm", ["install"], { cwd: userBridge, stdio: "pipe" });
+  if (install.status !== 0) {
+    console.error(`Bridge install failed: ${install.status ?? 1}`);
+    if (install.stderr) {
+      console.error(String(install.stderr).slice(0, 500));
+    }
+    process.exit(1);
+  }
+  const build = spawnSync("npm", ["run", "build"], { cwd: userBridge, stdio: "pipe" });
+  if (build.status !== 0) {
+    console.error(`Bridge build failed: ${build.status ?? 1}`);
+    if (build.stderr) {
+      console.error(String(build.stderr).slice(0, 500));
+    }
+    process.exit(1);
+  }
+  console.log("\u2713 Bridge ready\n");
+  return userBridge;
+}
+function getPackageVersion() {
+  try {
+    const cliDir = resolve(fileURLToPath(new URL(".", import.meta.url)));
+    const pkgPath = resolve(cliDir, "..", "..", "package.json");
+    const raw = readFileSync4(pkgPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function which(binary) {
+  const paths = (process.env.PATH ?? "").split(":");
+  for (const dir of paths) {
+    const full = join5(dir, binary);
+    if (existsSync5(full)) {
+      return true;
+    }
+  }
+  return false;
+}