botmux 2.2.7 → 2.3.1

package/dist/cli.js

@@ -21,8 +21,10 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
+import { createRequire } from 'node:module';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
 // Package root is one level up from dist/
 const PKG_ROOT = dirname(__dirname);
 const CONFIG_DIR = join(homedir(), '.botmux');
@@ -31,25 +33,48 @@ const DATA_DIR = join(CONFIG_DIR, 'data');
 const LOG_DIR = join(CONFIG_DIR, 'logs');
 const BOTS_JSON_FILE = join(CONFIG_DIR, 'bots.json');
 const PM2_NAME = 'botmux';
+/**
+ * Dedicated PM2_HOME for botmux. Isolates our pm2 daemon state from any
+ * other pm2 installation on the machine (e.g. the one bundled in IDE
+ * remote-ssh extensions). Prevents stale ProcessContainerFork.js paths
+ * when those external pm2 installations get moved or removed.
+ */
+const PM2_HOME = join(CONFIG_DIR, 'pm2');
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function ensureConfigDir() {
-    for (const dir of [CONFIG_DIR, DATA_DIR, LOG_DIR]) {
+    for (const dir of [CONFIG_DIR, DATA_DIR, LOG_DIR, PM2_HOME]) {
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
     }
 }
+/**
+ * Resolve the pm2 CLI script path. Uses require.resolve so it always lands
+ * on the pm2 bundled with this package, never on a PATH-resolved pm2 that
+ * may belong to an unrelated installation (e.g. IDE remote extensions).
+ */
 function pm2Bin() {
-    // Use the pm2 bundled with this package
-    const local = join(PKG_ROOT, 'node_modules', '.bin', 'pm2');
-    if (existsSync(local))
-        return local;
-    // Fallback to global pm2
+    try {
+        return require.resolve('pm2/bin/pm2');
+    }
+    catch { /* fall through */ }
+    // Fallbacks for unusual installation layouts
+    const direct = join(PKG_ROOT, 'node_modules', 'pm2', 'bin', 'pm2');
+    if (existsSync(direct))
+        return direct;
+    const symlink = join(PKG_ROOT, 'node_modules', '.bin', 'pm2');
+    if (existsSync(symlink))
+        return symlink;
     return 'pm2';
 }
-function runPm2(args, inherit = true) {
-    const result = inherit
-        ? execSync(`${pm2Bin()} ${args.join(' ')}`, { stdio: 'inherit', env: process.env })
-        : execSync(`${pm2Bin()} ${args.join(' ')}`, { env: process.env });
+/** Env for pm2 invocations with an isolated PM2_HOME. */
+function pm2Env(home = PM2_HOME) {
+    return { ...process.env, PM2_HOME: home };
+}
+function runPm2(args, inherit = true, home = PM2_HOME) {
+    execSync(`${pm2Bin()} ${args.join(' ')}`, {
+        stdio: inherit ? 'inherit' : 'pipe',
+        env: pm2Env(home),
+    });
 }
 function loadBotsJson() {
     if (existsSync(BOTS_JSON_FILE)) {
@@ -248,6 +273,7 @@ function cmdStart() {
         process.exit(1);
     }
     ensureConfigDir();
+    cleanupLegacyPm2();
     const cfg = ecosystemConfig();
     runPm2(['start', cfg]);
     const bots = loadBotsJson();
@@ -256,15 +282,24 @@ function cmdStart() {
     console.log(`   日志: botmux logs`);
     console.log(`   状态: botmux status`);
 }
-/** Delete all pm2 processes matching botmux / botmux-* */
-function deleteAllBotmuxProcesses() {
+/** Delete all pm2 processes matching botmux / botmux-* under the given PM2_HOME. */
+function deleteAllBotmuxProcesses(home = PM2_HOME) {
     try {
-        const output = execSync(`${pm2Bin()} jlist`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const output = execSync(`${pm2Bin()} jlist`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: pm2Env(home),
+            timeout: 10_000,
+        });
         const apps = JSON.parse(output);
         for (const app of apps) {
             if (app.name === PM2_NAME || app.name.startsWith(`${PM2_NAME}-`)) {
                 try {
-                    execSync(`${pm2Bin()} delete ${app.name}`, { stdio: ['pipe', 'pipe', 'pipe'] });
+                    execSync(`${pm2Bin()} delete ${app.name}`, {
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                        env: pm2Env(home),
+                        timeout: 10_000,
+                    });
                 }
                 catch { /* */ }
             }
@@ -272,10 +307,49 @@ function deleteAllBotmuxProcesses() {
     }
     catch { /* pm2 not running or no apps */ }
 }
+/**
+ * One-time migration for users upgrading from versions that used the default
+ * ~/.pm2 directory. Removes any lingering botmux-* processes registered under
+ * the legacy home so the new dedicated PM2_HOME becomes the sole source of
+ * truth. Only touches processes named `botmux` or `botmux-*` — the user's
+ * unrelated pm2 apps are left untouched. No-op on fresh installs.
+ */
+function cleanupLegacyPm2() {
+    const legacyHome = join(homedir(), '.pm2');
+    if (legacyHome === PM2_HOME)
+        return false;
+    const legacyPidFile = join(legacyHome, 'pm2.pid');
+    if (!existsSync(legacyPidFile))
+        return false;
+    let legacyPid = 0;
+    try {
+        legacyPid = parseInt(readFileSync(legacyPidFile, 'utf-8').trim(), 10);
+    }
+    catch {
+        return false;
+    }
+    if (!legacyPid)
+        return false;
+    // If the legacy daemon isn't alive anymore there's nothing to clean.
+    try {
+        process.kill(legacyPid, 0);
+    }
+    catch {
+        return false;
+    }
+    deleteAllBotmuxProcesses(legacyHome);
+    return true;
+}
 function cmdStop() {
+    cleanupLegacyPm2();
     let stopped = false;
     try {
-        const output = execSync(`${pm2Bin()} jlist`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const output = execSync(`${pm2Bin()} jlist`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: pm2Env(),
+            timeout: 10_000,
+        });
         const apps = JSON.parse(output);
         for (const app of apps) {
             if (app.name === PM2_NAME || app.name.startsWith(`${PM2_NAME}-`)) {
@@ -298,12 +372,56 @@ function cmdRestart() {
         process.exit(1);
     }
     ensureConfigDir();
+    cleanupLegacyPm2();
     // Delete all botmux processes (handles both old single-process and new multi-process)
     deleteAllBotmuxProcesses();
     const cfg = ecosystemConfig();
     runPm2(['start', cfg]);
 }
+/**
+ * If a legacy ~/.pm2 daemon with botmux processes still exists alongside our
+ * new PM2_HOME, warn the user so read-only commands (status/logs) don't
+ * silently show an empty new home while the old daemon keeps running.
+ */
+function warnIfLegacyBotmuxAlive() {
+    const legacyHome = join(homedir(), '.pm2');
+    if (legacyHome === PM2_HOME)
+        return;
+    const legacyPidFile = join(legacyHome, 'pm2.pid');
+    if (!existsSync(legacyPidFile))
+        return;
+    let legacyPid = 0;
+    try {
+        legacyPid = parseInt(readFileSync(legacyPidFile, 'utf-8').trim(), 10);
+    }
+    catch {
+        return;
+    }
+    if (!legacyPid)
+        return;
+    try {
+        process.kill(legacyPid, 0);
+    }
+    catch {
+        return;
+    }
+    try {
+        const output = execSync(`${pm2Bin()} jlist`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: pm2Env(legacyHome),
+            timeout: 10_000,
+        });
+        const apps = JSON.parse(output);
+        const hasBotmux = apps.some(a => a.name === PM2_NAME || a.name.startsWith(`${PM2_NAME}-`));
+        if (hasBotmux) {
+            console.warn('⚠️  检测到旧版 PM2_HOME (~/.pm2) 下仍有 botmux 进程,运行 `botmux restart` 完成迁移。\n');
+        }
+    }
+    catch { /* ignore */ }
+}
 function cmdLogs() {
+    warnIfLegacyBotmuxAlive();
     const lines = process.argv.includes('--lines')
         ? process.argv[process.argv.indexOf('--lines') + 1] || '50'
         : '50';
@@ -323,11 +441,12 @@ function cmdLogs() {
     // Use spawn for streaming output
     const child = spawn(pm2Bin(), ['logs', target, '--lines', lines], {
         stdio: 'inherit',
-        env: process.env,
+        env: pm2Env(),
     });
     child.on('exit', code => process.exit(code ?? 0));
 }
 function cmdStatus() {
+    warnIfLegacyBotmuxAlive();
     runPm2(['status']);
 }
 function cmdUpgrade() {
@@ -957,10 +1076,593 @@ botmux v${getVersion()} — IM ↔ AI 编程 CLI 桥接
   delete all       关闭所有活跃会话
   delete stopped   清理所有进程已退出的僵尸会话
 
+定时任务（可在 CLI 会话内自动推断 chat）:
+  schedule list                        列出所有任务
+  schedule add <schedule> <prompt>     添加任务（ex: "30m" / "every 2h" / "每日9:00" / "0 9 * * *"）
+  schedule remove <id>                 删除任务
+  schedule pause|resume <id>           暂停/恢复
+  schedule run <id>                    标记立即执行
+
+飞书消息（在 CLI 会话内自动推断 session）:
+  send [content]                       发消息到当前话题（支持 stdin / --content-file）
+       --images <path>                 内联图片（可重复）
+       --files <path>                  附件（可重复）
+       --mention <open_id:name>        @提及（可重复）
+  bots list                            列出当前群聊中的机器人（含 open_id）
+  thread messages [--limit N]          拉取当前话题的消息历史 (JSON)
+
 配置目录: ~/.botmux/
 文档: https://github.com/deepcoldy/botmux
 `);
 }
+// ─── Schedule subcommands ────────────────────────────────────────────────────
+/**
+ * Walk the process tree looking for a CLI-pid marker written by the botmux
+ * worker. Returns the sessionId stored in the marker (or '' if empty/legacy).
+ *
+ * This mirrors server.ts:findAncestorCliMarker but is local to cli.ts so
+ * subcommands invoked from inside an agent session can auto-detect which
+ * session they belong to.
+ */
+function findAncestorSessionId() {
+    const dataDir = resolveDataDir();
+    const markersDir = join(dataDir, '.botmux-cli-pids');
+    if (!existsSync(markersDir))
+        return null;
+    let pid = process.ppid;
+    for (let depth = 0; depth < 8 && pid > 1; depth++) {
+        const markerPath = join(markersDir, String(pid));
+        if (existsSync(markerPath)) {
+            try {
+                return readFileSync(markerPath, 'utf-8').trim();
+            }
+            catch {
+                return '';
+            }
+        }
+        try {
+            const out = execSync(`ps -o ppid= -p ${pid}`, { encoding: 'utf-8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+            pid = parseInt(out, 10);
+            if (isNaN(pid))
+                break;
+        }
+        catch {
+            break;
+        }
+    }
+    return null;
+}
+/** Detect current session info from ancestor marker + session files. */
+function detectCurrentSession() {
+    const sid = findAncestorSessionId();
+    if (!sid)
+        return null;
+    const sessions = loadSessions();
+    const s = sessions.get(sid);
+    if (!s)
+        return null;
+    return {
+        sessionId: s.sessionId,
+        chatId: s.chatId,
+        rootMessageId: s.rootMessageId,
+        workingDir: s.workingDir,
+        larkAppId: s.larkAppId,
+        chatType: s.chatType,
+    };
+}
+/** Pick a value from --flag <value> or --flag=value style args. */
+function argValue(args, ...flags) {
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        for (const f of flags) {
+            if (a === f && i + 1 < args.length)
+                return args[i + 1];
+            if (a.startsWith(f + '='))
+                return a.slice(f.length + 1);
+        }
+    }
+    return undefined;
+}
+function argFlag(args, flag) {
+    return args.includes(flag);
+}
+/** Extract positional args, skipping --flag and the value that follows it
+ *  (for --flag <value> style).  --flag=value style is self-contained. */
+function positionals(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('--')) {
+            if (!a.includes('=') && i + 1 < args.length)
+                i++; // skip value
+            continue;
+        }
+        out.push(a);
+    }
+    return out;
+}
+async function cmdSchedule(sub, rest) {
+    // Ensure SESSION_DATA_DIR points at the daemon's data dir so schedule-store
+    // writes to the right file even when invoked outside the daemon env.
+    process.env.SESSION_DATA_DIR ??= resolveDataDir();
+    const scheduler = await import('./core/scheduler.js');
+    const scheduleStore = await import('./services/schedule-store.js');
+    if (!sub || sub === 'list' || sub === 'ls') {
+        const tasks = scheduleStore.listTasks();
+        if (tasks.length === 0) {
+            console.log('暂无定时任务。\n\n用法:\n  botmux schedule add "每日17:50" "帮我看AI新闻"\n  botmux schedule add "every 2h" "检查构建"\n  botmux schedule add "0 9 * * *" "每天早安"');
+            return;
+        }
+        const filter = argValue(rest, '--chat-id');
+        const filtered = filter ? tasks.filter(t => t.chatId === filter) : tasks;
+        console.log(`定时任务 (${filtered.length}${filter ? '/' + tasks.length : ''}):\n`);
+        for (const t of filtered) {
+            const status = t.enabled ? '✅' : '⏸️';
+            const next = t.nextRunAt ? new Date(t.nextRunAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }) : '—';
+            const last = t.lastRunAt ? new Date(t.lastRunAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }) : '—';
+            const display = t.parsed?.display ?? t.schedule;
+            const prompt = t.prompt ?? '';
+            const chatId = t.chatId ?? '—';
+            const rootId = t.rootMessageId ?? '—';
+            console.log(`${status} [${t.id}] ${display} | ${t.name}`);
+            console.log(`   prompt: ${prompt.length > 60 ? prompt.slice(0, 60) + '…' : prompt}`);
+            console.log(`   chat: ${chatId.slice(0, 12)}…   thread: ${rootId.slice(0, 16)}…`);
+            console.log(`   next: ${next}   last: ${last}${t.lastStatus === 'error' ? ' ❌' : ''}`);
+            console.log('');
+        }
+        return;
+    }
+    if (sub === 'add') {
+        const [rawSchedule, ...promptParts] = positionals(rest);
+        if (!rawSchedule) {
+            console.error('用法: botmux schedule add <schedule> <prompt> [--name NAME] [--chat-id CHAT] [--root-msg-id ROOT] [--lark-app-id APP] [--workdir DIR]');
+            process.exit(1);
+        }
+        // prompt may come from positional or --prompt flag
+        const promptArg = argValue(rest, '--prompt') ?? promptParts.join(' ');
+        if (!promptArg) {
+            console.error('缺少 prompt。用法: botmux schedule add <schedule> <prompt>');
+            process.exit(1);
+        }
+        const cur = detectCurrentSession();
+        const chatId = argValue(rest, '--chat-id') ?? cur?.chatId;
+        const rootMessageId = argValue(rest, '--root-msg-id') ?? cur?.rootMessageId;
+        const larkAppId = argValue(rest, '--lark-app-id') ?? cur?.larkAppId;
+        const workingDir = argValue(rest, '--workdir') ?? cur?.workingDir ?? process.cwd();
+        const name = argValue(rest, '--name') ?? (promptArg.length > 20 ? promptArg.slice(0, 20) + '…' : promptArg);
+        const deliver = argValue(rest, '--deliver') ?? 'origin';
+        if (!chatId) {
+            console.error('无法推断 chat-id。请加上 --chat-id <CHAT_ID>，或从 Lark 话题内的 CLI 会话中运行本命令。');
+            process.exit(1);
+        }
+        let parsed;
+        try {
+            parsed = scheduler.parseSchedule(rawSchedule);
+        }
+        catch (err) {
+            console.error(`无法解析 schedule "${rawSchedule}": ${err.message}`);
+            process.exit(1);
+        }
+        const task = scheduler.addTask({
+            name,
+            schedule: rawSchedule,
+            parsed,
+            prompt: promptArg,
+            workingDir,
+            chatId,
+            rootMessageId,
+            larkAppId,
+            chatType: cur?.chatType === 'p2p' ? 'p2p' : 'topic_group',
+            deliver,
+        });
+        const next = task.nextRunAt ? new Date(task.nextRunAt).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }) : '—';
+        console.log(`✅ 已创建定时任务 [${task.id}] ${task.name}`);
+        console.log(`   规则: ${parsed.display}`);
+        console.log(`   下次执行: ${next}`);
+        console.log(`   工作目录: ${workingDir}`);
+        console.log(`   话题: ${rootMessageId ?? '(将新开)'}`);
+        return;
+    }
+    const id = positionals(rest)[0];
+    if (!id) {
+        console.error(`用法: botmux schedule ${sub} <id>`);
+        process.exit(1);
+    }
+    switch (sub) {
+        case 'remove':
+        case 'rm':
+        case 'delete':
+        case 'del':
+            if (scheduler.removeTask(id))
+                console.log(`已删除任务 ${id}`);
+            else {
+                console.error(`未找到任务 ${id}`);
+                process.exit(1);
+            }
+            break;
+        case 'pause':
+        case 'disable':
+            if (scheduler.disableTask(id))
+                console.log(`已暂停任务 ${id}`);
+            else {
+                console.error(`未找到任务 ${id}`);
+                process.exit(1);
+            }
+            break;
+        case 'resume':
+        case 'enable':
+            if (scheduler.enableTask(id))
+                console.log(`已恢复任务 ${id}`);
+            else {
+                console.error(`未找到任务 ${id}`);
+                process.exit(1);
+            }
+            break;
+        case 'run':
+            // Running requires the daemon (executeCallback is daemon-side).
+            // CLI can only mark a task to run ASAP; daemon's next tick picks it up.
+            {
+                const task = scheduleStore.getTask(id);
+                if (!task) {
+                    console.error(`未找到任务 ${id}`);
+                    process.exit(1);
+                }
+                scheduleStore.updateTask(id, { nextRunAt: new Date().toISOString() });
+                console.log(`已标记任务 ${id} 下次 tick 立即执行（< 30s）`);
+            }
+            break;
+        default:
+            console.error(`未知子命令: ${sub}\n可用: list | add | remove | pause | resume | run`);
+            process.exit(1);
+    }
+}
+async function cmdThreadMessages(rest) {
+    process.env.SESSION_DATA_DIR ??= resolveDataDir();
+    const limit = parseInt(argValue(rest, '--limit') ?? '50', 10);
+    const sessionIdArg = argValue(rest, '--session-id');
+    const sid = sessionIdArg ?? findAncestorSessionId();
+    if (!sid) {
+        console.error('无法推断 session-id。请在 Lark 话题内的 CLI 会话中运行，或传 --session-id <id>。');
+        process.exit(1);
+    }
+    const sessions = loadSessions();
+    const s = sessions.get(sid);
+    if (!s) {
+        console.error(`未找到 session ${sid}`);
+        process.exit(1);
+    }
+    if (!s.larkAppId) {
+        console.error(`session ${sid} 缺少 larkAppId，无法获取消息`);
+        process.exit(1);
+    }
+    // Ensure bot is registered so getBotClient works
+    const { registerBot, loadBotConfigs } = await import('./bot-registry.js');
+    try {
+        for (const cfg of loadBotConfigs())
+            registerBot(cfg);
+    }
+    catch { /* ignore */ }
+    const { listThreadMessages } = await import('./im/lark/client.js');
+    const { parseApiMessage } = await import('./im/lark/message-parser.js');
+    try {
+        const raw = await listThreadMessages(s.larkAppId, s.chatId, s.rootMessageId, limit);
+        const messages = raw.map(parseApiMessage);
+        console.log(JSON.stringify({ sessionId: sid, threadId: s.rootMessageId, messages, total: messages.length }, null, 2));
+    }
+    catch (err) {
+        console.error(`获取话题消息失败: ${err.message}`);
+        process.exit(1);
+    }
+}
+// ─── Send subcommand ─────────────────────────────────────────────────────────
+/** Read all of stdin until EOF. Returns '' if stdin is a TTY (no piped data). */
+function readStdin() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve('');
+            return;
+        }
+        const chunks = [];
+        process.stdin.on('data', (c) => chunks.push(c));
+        process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        process.stdin.on('error', () => resolve(''));
+    });
+}
+/** Collect all values for a repeatable flag: --flag v1 --flag v2 */
+function argValues(args, ...flags) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        for (const f of flags) {
+            if (args[i] === f && i + 1 < args.length) {
+                out.push(args[++i]);
+                break;
+            }
+            if (args[i].startsWith(f + '=')) {
+                out.push(args[i].slice(f.length + 1));
+                break;
+            }
+        }
+    }
+    return out;
+}
+async function cmdSend(rest) {
+    process.env.SESSION_DATA_DIR ??= resolveDataDir();
+    const sessionIdArg = argValue(rest, '--session-id');
+    const images = argValues(rest, '--image', '--images');
+    const files = argValues(rest, '--file', '--files');
+    const mentionArgs = argValues(rest, '--mention'); // "open_id:Display Name"
+    const contentFile = argValue(rest, '--content-file');
+    const sid = sessionIdArg ?? findAncestorSessionId();
+    if (!sid) {
+        console.error('无法推断 session-id。请在 Lark 话题内的 CLI 会话中运行，或传 --session-id <id>。');
+        process.exit(1);
+    }
+    const sessions = loadSessions();
+    const s = sessions.get(sid);
+    if (!s) {
+        console.error(`未找到 session ${sid}`);
+        process.exit(1);
+    }
+    if (!s.larkAppId) {
+        console.error(`session ${sid} 缺少 larkAppId`);
+        process.exit(1);
+    }
+    // Read content from: --content-file > positional arg > stdin
+    let content = '';
+    if (contentFile) {
+        if (!existsSync(contentFile)) {
+            console.error(`文件不存在: ${contentFile}`);
+            process.exit(1);
+        }
+        content = readFileSync(contentFile, 'utf-8');
+    }
+    else {
+        const pos = positionals(rest);
+        if (pos.length > 0) {
+            content = pos.join(' ');
+        }
+        else {
+            content = await readStdin();
+        }
+    }
+    if (!content.trim() && images.length === 0 && files.length === 0) {
+        console.error('没有内容可发送。用法:\n  echo "消息" | botmux send\n  botmux send "消息"\n  botmux send --content-file /tmp/msg.md --images /tmp/chart.png');
+        process.exit(1);
+    }
+    // Parse mentions: "open_id:Display Name"
+    const mentions = [];
+    for (const m of mentionArgs) {
+        const idx = m.indexOf(':');
+        if (idx > 0) {
+            mentions.push({ open_id: m.slice(0, idx), name: m.slice(idx + 1) });
+        }
+    }
+    // Validate file paths
+    for (const p of [...images, ...files]) {
+        if (!existsSync(p)) {
+            console.error(`文件不存在: ${p}`);
+            process.exit(1);
+        }
+    }
+    // Register bots so Lark client works
+    const { registerBot, loadBotConfigs } = await import('./bot-registry.js');
+    try {
+        for (const cfg of loadBotConfigs())
+            registerBot(cfg);
+    }
+    catch { /* */ }
+    const { replyMessage, uploadImage, uploadFile } = await import('./im/lark/client.js');
+    const appId = s.larkAppId;
+    try {
+        // Upload images in parallel
+        const imageKeys = [];
+        if (images.length > 0) {
+            const results = await Promise.all(images.map(p => uploadImage(appId, p)));
+            imageKeys.push(...results);
+        }
+        // Try to extract plain text if Claude accidentally sent post JSON as content
+        let text = content;
+        try {
+            const parsed = JSON.parse(text);
+            const inner = parsed.zh_cn ?? parsed.en_us ?? parsed;
+            if (Array.isArray(inner?.content)) {
+                const lines = [];
+                for (const para of inner.content) {
+                    if (!Array.isArray(para))
+                        continue;
+                    lines.push(para.filter((n) => n.tag === 'text').map((n) => n.text).join(''));
+                }
+                text = lines.join('\n').trim();
+            }
+        }
+        catch { /* not JSON, use as-is */ }
+        // Build post content: text → paragraphs, with @mention replacement
+        let mentionPattern = null;
+        const mentionMap = new Map();
+        if (mentions.length > 0) {
+            const patterns = mentions.map(m => m.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            mentionPattern = new RegExp(`@(${patterns.join('|')})\\b`, 'gi');
+            for (const m of mentions)
+                mentionMap.set(m.name.toLowerCase(), m.open_id);
+        }
+        const postContent = text ? text.split('\n').map((line) => {
+            if (!mentionPattern)
+                return [{ tag: 'text', text: line }];
+            const nodes = [];
+            let lastIndex = 0;
+            for (const match of line.matchAll(mentionPattern)) {
+                const openId = mentionMap.get(match[1].toLowerCase());
+                if (!openId)
+                    continue;
+                if (match.index > lastIndex)
+                    nodes.push({ tag: 'text', text: line.slice(lastIndex, match.index) });
+                nodes.push({ tag: 'at', user_id: openId });
+                lastIndex = match.index + match[0].length;
+            }
+            if (lastIndex < line.length)
+                nodes.push({ tag: 'text', text: line.slice(lastIndex) });
+            return nodes.length > 0 ? nodes : [{ tag: 'text', text: line }];
+        }) : [];
+        for (const key of imageKeys)
+            postContent.push([{ tag: 'img', image_key: key }]);
+        // Unused mentions → append at end
+        if (mentions.length > 0) {
+            const usedIds = new Set();
+            for (const para of postContent)
+                for (const n of para)
+                    if (n.tag === 'at')
+                        usedIds.add(n.user_id);
+            const unused = mentions.filter(m => !usedIds.has(m.open_id));
+            if (unused.length > 0) {
+                if (postContent.length === 0)
+                    postContent.push([]);
+                for (const m of unused)
+                    postContent[postContent.length - 1].push({ tag: 'at', user_id: m.open_id });
+            }
+        }
+        // Append @mention to session owner
+        if (s.ownerOpenId) {
+            if (postContent.length === 0)
+                postContent.push([]);
+            postContent[postContent.length - 1].push({ tag: 'at', user_id: s.ownerOpenId });
+        }
+        const postJson = JSON.stringify({ zh_cn: { title: '', content: postContent } });
+        const messageId = await replyMessage(appId, s.rootMessageId, postJson, 'post', true);
+        // Send file attachments as separate messages
+        const fileIds = [];
+        for (const fp of files) {
+            const fileKey = await uploadFile(appId, fp);
+            const fid = await replyMessage(appId, s.rootMessageId, JSON.stringify({ file_key: fileKey }), 'file', true);
+            fileIds.push(fid);
+        }
+        // Bot-to-bot mention signals
+        const dataDir = resolveDataDir();
+        const botInfoPath = join(dataDir, 'bots-info.json');
+        let botEntries = [];
+        try {
+            if (existsSync(botInfoPath))
+                botEntries = JSON.parse(readFileSync(botInfoPath, 'utf-8'));
+        }
+        catch { /* */ }
+        const openIdToAppId = new Map();
+        for (const e of botEntries)
+            if (e.botOpenId)
+                openIdToAppId.set(e.botOpenId, e.larkAppId);
+        try {
+            for (const file of readdirSync(dataDir)) {
+                if (!file.startsWith('bot-openids-') || !file.endsWith('.json'))
+                    continue;
+                try {
+                    const crossRef = JSON.parse(readFileSync(join(dataDir, file), 'utf-8'));
+                    for (const [botName, crossOpenId] of Object.entries(crossRef)) {
+                        const entry = botEntries.find(e => e.botName?.toLowerCase() === botName.toLowerCase());
+                        if (entry)
+                            openIdToAppId.set(crossOpenId, entry.larkAppId);
+                    }
+                }
+                catch { /* */ }
+            }
+        }
+        catch { /* */ }
+        const targetAppIds = new Set();
+        for (const m of mentions) {
+            const ta = openIdToAppId.get(m.open_id);
+            if (ta && ta !== appId)
+                targetAppIds.add(ta);
+        }
+        if (text && botEntries.length > 0) {
+            for (const entry of botEntries) {
+                if (!entry.botOpenId || entry.larkAppId === appId)
+                    continue;
+                const names = [entry.botName, entry.cliId].filter(Boolean);
+                for (const name of names) {
+                    if (new RegExp(`@${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(text)) {
+                        targetAppIds.add(entry.larkAppId);
+                        break;
+                    }
+                }
+            }
+        }
+        if (targetAppIds.size > 0) {
+            const signalDir = join(dataDir, 'bot-mentions');
+            if (!existsSync(signalDir))
+                mkdirSync(signalDir, { recursive: true });
+            for (const targetApp of targetAppIds) {
+                const te = botEntries.find(e => e.larkAppId === targetApp);
+                const signal = {
+                    rootMessageId: s.rootMessageId, chatId: s.chatId, chatType: s.chatType,
+                    senderAppId: appId, targetBotOpenId: te?.botOpenId ?? targetApp,
+                    content: text, messageId, timestamp: Date.now(),
+                };
+                writeFileSync(join(signalDir, `${Date.now()}-${(te?.botOpenId ?? targetApp).slice(-8)}.json`), JSON.stringify(signal));
+            }
+        }
+        console.log(JSON.stringify({ success: true, messageId, sessionId: sid }));
+    }
+    catch (err) {
+        console.error(`发送失败: ${err.message}`);
+        process.exit(1);
+    }
+}
+// ─── Bots subcommand ─────────────────────────────────────────────────────────
+async function cmdBots(sub, rest) {
+    process.env.SESSION_DATA_DIR ??= resolveDataDir();
+    if (sub !== 'list' && sub !== 'ls' && sub !== '') {
+        console.error('用法: botmux bots list [--session-id ID]');
+        process.exit(1);
+    }
+    const sessionIdArg = argValue(rest, '--session-id');
+    const sid = sessionIdArg ?? findAncestorSessionId();
+    if (!sid) {
+        console.error('无法推断 session-id。请在 Lark 话题内的 CLI 会话中运行，或传 --session-id <id>。');
+        process.exit(1);
+    }
+    const sessions = loadSessions();
+    const s = sessions.get(sid);
+    if (!s) {
+        console.error(`未找到 session ${sid}`);
+        process.exit(1);
+    }
+    if (!s.larkAppId) {
+        console.error(`session ${sid} 缺少 larkAppId`);
+        process.exit(1);
+    }
+    // Register bots
+    const { registerBot, loadBotConfigs } = await import('./bot-registry.js');
+    try {
+        for (const cfg of loadBotConfigs())
+            registerBot(cfg);
+    }
+    catch { /* */ }
+    const appId = s.larkAppId;
+    const dataDir = resolveDataDir();
+    const botInfoPath = join(dataDir, 'bots-info.json');
+    let botEntries = [];
+    try {
+        if (existsSync(botInfoPath))
+            botEntries = JSON.parse(readFileSync(botInfoPath, 'utf-8'));
+    }
+    catch { /* */ }
+    const botByCli = new Map();
+    for (const b of botEntries)
+        botByCli.set(b.cliId, b);
+    try {
+        const { listChatBotMembers } = await import('./im/lark/client.js');
+        const chatBots = await listChatBotMembers(appId, s.chatId);
+        const result = chatBots.map(cb => {
+            const info = botByCli.get(cb.name);
+            return { name: cb.displayName, openId: cb.openId, isSelf: info?.larkAppId === appId };
+        });
+        console.log(JSON.stringify({ sessionId: sid, chatId: s.chatId, bots: result, total: result.length }, null, 2));
+    }
+    catch (err) {
+        // Fallback to bots-info.json
+        const result = botEntries.filter(b => b.botOpenId).map(b => ({
+            name: b.botName ?? b.cliId, openId: b.botOpenId, isSelf: b.larkAppId === appId,
+        }));
+        console.log(JSON.stringify({ sessionId: sid, bots: result, total: result.length, note: `chat query failed: ${err.message}` }, null, 2));
+    }
+}
 // ─── Main ────────────────────────────────────────────────────────────────────
 function getVersion() {
     const pkgPath = join(PKG_ROOT, 'package.json');
@@ -1008,6 +1710,25 @@ switch (command) {
     case 'rm':
         cmdDelete();
         break;
+    case 'schedule':
+        await cmdSchedule(process.argv[3] ?? '', process.argv.slice(4));
+        break;
+    case 'send':
+        await cmdSend(process.argv.slice(3));
+        break;
+    case 'bots':
+        await cmdBots(process.argv[3] ?? 'list', process.argv.slice(4));
+        break;
+    case 'thread': {
+        const sub = process.argv[3] ?? '';
+        if (sub === 'messages' || sub === 'msgs')
+            await cmdThreadMessages(process.argv.slice(4));
+        else {
+            console.error(`用法: botmux thread messages [--limit N] [--session-id ID]`);
+            process.exit(1);
+        }
+        break;
+    }
     default:
         showHelp();
         break;