mocode-ai 1.6.5 → 1.6.6

package/README.md

@@ -117,9 +117,15 @@ MoCode isn't a chat box with a coat of paint — it's an agent that actually get
 - **Streaming output + visible reasoning** — Responses render as they're generated; when the model supports reasoning, the thinking process is visible in real time and auto-collapses to save screen space.
 - **Full-screen TUI** — Alt-screen mode with a fixed status bar, scrollback (PgUp/PgDn), typeahead while the agent is running, and auto-prefill for the next turn.
 - **Session persistence** — Every turn is saved automatically; `--resume` / `/resume` picks up a past session.
+- **Background jobs** — `mocode run --bg "task"` spawns a detached process that survives terminal close; state and logs land in `.mocode/jobs/`, and `/jobs` lists, tails logs, or kills them. Set `MOCODE_NOTIFY_WEBHOOK` to push a finish notification (ntfy/Bark/Telegram/generic). When an unattended job hits an unauthorised confirm/dangerous action it parks (status `paused`) and pings you; approve in another terminal with `mocode approve <id>` (`mocode deny` to reject, or `/jobs approve` inside the TUI), and it resumes in the same process. Follow a running (or finished) job live with `mocode attach <id>`. Long jobs checkpoint their history after every tool batch; if the process dies or the machine reboots, `mocode resume-job <id>` replays from the last checkpoint (in-flight work is re-run). `MOCODE_JOB_MAX_MS` / `MOCODE_JOB_MAX_TOKENS` add hard wall-clock/token caps.
+- **Named bots** — `mocode bots add` defines role-based bots (job-specific system prompt + optional exact-tool whitelist + sandbox scope) at project/global level; run with `--bot <name>`, combine with `run --bg` or schedules.
+- **Arena** — The `arena` tool runs the same task N times (2-6) as parallel independent workers, then a judge model ranks every candidate against your criteria and returns the winner with the full ranking. Useful for design/exploration/problem-solving where several attempts beat one.
+- **Persistent bot messaging** — The `message_bus` tool gives named bots a durable, asynchronous message store (`send` / `inbox` / `ack` / `history`): a supervisor bot can hand off work to another bot that is not currently running; the worker reads its inbox later (e.g. when a schedule wakes it), does the job, and replies. Identity follows the `--bot` identity, and each bot only sees/acks its own messages.
+- **Scheduled tasks** — `mocode schedule add` registers cron and/or webhook triggers; a local detached daemon (`schedule start`, loopback-only) fires background jobs on time or on `POST /trigger/<token>`, with per-minute dedup. A stateless `schedule tick` is also available for OS task schedulers.
+- **Headless one-shot mode** — `mocode -p "task"` or piped `echo "task" | mocode`, with optional `--json` structured output; confirm/dangerous actions are denied by default when non-interactive (opt in with `--dangerously-skip-permissions`; `--verbose` adds tool-result summaries, `--session-dir <dir>`, `--worktree` ephemeral git worktree), and sessions are still saved for `--resume`.
 - **Skills system** — Scans directories like `~/.mocode/skills/` automatically; each skill's description is injected into the system prompt, and the model calls `use_skill` to load the full instructions only when relevant (progressive disclosure: skim the summary first, load the body only if needed).
 - **Optional desktop pet** — A small floating window (`/pet`) shows a stateful character that mirrors agent activity (idle / thinking / tool running / waiting for human). Works as a separate process over WebSocket; quit it with `/pet quit`. Sits beside the terminal, never blocks it.
-- **Slash commands** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`, with dropdown filtering as you type.
+- **Slash commands** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/jobs` `/schedules` `/bots` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`, with dropdown filtering as you type.
 
 ## Documentation
 

package/README.zh-CN.md

@@ -116,9 +116,15 @@ mocode 不是一个套壳聊天框,而是一个能真正动手干活的 agent:
 - **流式输出 + 思考可见** — 回复边生成边显示;模型支持 reasoning 时思考过程实时可见,思考段自动折叠(不占屏)
 - **全屏 TUI** — 备用屏(alt screen)+ 固定底栏状态行 + 滚动回看(PgUp/PgDn),运行中可打字(typeahead),下一轮自动预填
 - **会话持久化** — 每轮自动落盘,`--resume` / `/resume` 续接历史会话
+- **后台任务** — `mocode run --bg "任务"` 派 detached 子进程,关终端不死;状态与日志落 `.mocode/jobs/`,`/jobs` 可列表/看日志/kill。设 `MOCODE_NOTIFY_WEBHOOK` 后,任务结束自动推送通知(ntfy/Bark/Telegram/generic)。无人值守任务遇到未授权的 confirm/dangerous 动作时会挂起(状态 `paused`)并通知你;在另一终端敲 `mocode approve <id>` 批准(`mocode deny` 拒绝,或 TUI 内 `/jobs approve`),任务在同一进程内续跑。用 `mocode attach <id>` 可实时跟随运行中(或已结束)的任务。长任务在每个工具批次后落 checkpoint;进程挂掉或机器重启后,`mocode resume-job <id>` 从最后 checkpoint 重放(在途动作会重跑)。`MOCODE_JOB_MAX_MS` / `MOCODE_JOB_MAX_TOKENS` 提供硬性时长/token 上限。
+- **具名 Bot** — `mocode bots add` 定义岗位 Bot(专属系统提示 + 可选工具白名单 + 沙箱范围),项目/全局两级;`--bot <name>` 按名运行,可与后台/schedules 组合。
+- **Arena 竞技场** — `arena` 工具把同一任务并行跑 N 遍(2-6,各自独立),再由 judge 模型按你给的标准对所有候选打分排序,返回排名和最优方案。适合设计/探索/解题这类“多跑几遍选最好”的场景。
+- **持久 Bot 消息协作** — `message_bus` 工具给具名 bot 提供持久的异步消息存储(`send`/`inbox`/`ack`/`history`):主管 bot 可把活交给当前没在运行的 bot;worker 之后(如被计划任务唤起)拉 inbox、干活、回复。身份随 `--bot` 走,每个 bot 只能看到/确认发给自己的消息。
+- **计划任务** — `mocode schedule add` 注册 cron / webhook 触发;本地 detached 守护(`schedule start`,仅回环)到点或被 `POST /trigger/<token>` 触发即派后台 job,分钟去重;另有 `schedule tick` 供系统任务计划调用。
+- **Headless 一次性执行** — `mocode -p "任务"` 或管道 `echo "任务" | mocode`,可选 `--json` 结构化输出;非交互下 confirm/dangerous 操作默认拒绝(`--dangerously-skip-permissions` 显式放开;`--verbose` 追加工具结果摘要、`--session-dir <目录>`、`--worktree` git 隔离工作树),会话仍自动落盘可 `--resume`
 - **Skills 系统** — 自动扫描 `~/.mocode/skills/` 等目录,description 注入系统提示,模型按需调 `use_skill` 加载完整指令(渐进式披露:先看简介,任务相关才加载正文)
 - **可选桌宠** — 独立悬浮窗(`/pet`)显示一个小角色,镜像 agent 活动(空闲 / 思考 / 跑工具 / 等人工),独立进程走 WebSocket,`/pet quit` 完全关闭。挂在终端外,绝不挡终端。
-- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`,输入时下拉过滤
+- **斜杠命令** — `/exit` `/clear` `/cd` `/context` `/skills` `/compact` `/resume` `/rollback` `/jobs` `/schedules` `/bots` `/memory` `/reflect` `/init` `/theme` `/model` `/effort` `/stats` `/plan` `/auto` `/pet`,输入时下拉过滤
 
 ## 使用文档
 

package/dist/agent/run-coordinator.js

@@ -64,7 +64,8 @@ export async function runAgentCoreLegacy(opts, historyManager, stages) {
     const turnLifecycle = createTurnLifecycle(opts, ctx, stages, savedMode);
     const { usageMeter, emitTrace, traceTurnId } = turnLifecycle;
     const toolTurnPlanState = { stepsSincePlanTouch: 0 };
-    historyManager.appendUserTurn(userInput);
+    if (!opts.continueFromHistory)
+        historyManager.appendUserTurn(userInput);
     // P2:每用户 turn 一个重复读 scope,经 dispatcher → ToolContext 透传给 read_file。
     const readDedup = createReadDedup();
     // The initial cancellation checkpoint is captured after the user turn and before any model/tool work.

package/dist/agent/tool-turn.js

@@ -78,6 +78,8 @@ export async function runToolTurn(input) {
         rebuildHistoryIndexes();
         throw error;
     }
+    // D3: batch committed (staged shadow pushed into backing) -> persist full history.
+    hooks.onCheckpoint?.(opts.history);
     hooks.onToolBatchEnd?.();
     cancellationLifecycle.checkpoint();
     const batchDecision = terminationPolicy.decide({

package/dist/bots/bus.js

@@ -0,0 +1,117 @@
+// D1 持久 Bot 消息总线：bot 之间（以及 main 用户与 bot 之间）跨时间的异步消息。
+// 与同步 sub-agent 的区别：收发双方不必同时在线——消息落盘，worker bot 之后由
+// scheduler / bg 唤起时拉 inbox 处理并回结果。
+//
+// 存储（<sandboxRoot>/.mocode/bus/）：
+//   <msgId>.json            一条消息（只创建、永不改写 → 并发安全，无丢消息）
+//   <receiver>.read.json    该接收者已读消息 id 数组（低频 RMW，原子写）
+//
+// 身份用 AsyncLocalStorage 注入（runAsIdentity）：headless --bot X 时整段运行为 X，
+// 其内派生的 sub-agent 自动继承；缺省身份为 'main'（用户主会话）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomBytes } from 'node:crypto';
+import { getSandboxRoot } from '../sandbox/index.js';
+export const DEFAULT_IDENTITY = 'main';
+const identityStorage = new AsyncLocalStorage();
+/** 在指定 bot 身份下执行 fn；子 agent / 工具内 getIdentity() 都返回该身份。 */
+export function runAsIdentity(identity, fn) {
+    return identityStorage.run(identity, fn);
+}
+export function getIdentity() {
+    return identityStorage.getStore() ?? DEFAULT_IDENTITY;
+}
+function busRoot() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'bus');
+}
+function messagePath(id) {
+    return path.join(busRoot(), `${id}.json`);
+}
+function readMarkerPath(receiver) {
+    // receiver 只允许安全文件名段，杜绝路径穿越。
+    const safe = receiver.replace(/[^a-zA-Z0-9_.-]/g, '_');
+    return path.join(busRoot(), `${safe}.read.json`);
+}
+export function sendMessage(input) {
+    const to = input.to.trim();
+    const body = input.body;
+    if (!to)
+        throw new Error('message recipient (to) is required');
+    if (!body)
+        throw new Error('message body is required');
+    const msg = {
+        id: `msg-${Date.now().toString(36)}-${randomBytes(3).toString('hex')}`,
+        from: (input.from ?? getIdentity()).trim() || DEFAULT_IDENTITY,
+        to,
+        body,
+        createdAt: new Date().toISOString(),
+        ...(input.inReplyTo ? { inReplyTo: input.inReplyTo } : {}),
+    };
+    fs.mkdirSync(busRoot(), { recursive: true });
+    const target = messagePath(msg.id);
+    fs.writeFileSync(`${target}.tmp`, `${JSON.stringify(msg, null, 2)}\n`, 'utf8');
+    fs.renameSync(`${target}.tmp`, target);
+    return msg;
+}
+function getReadSet(receiver) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(readMarkerPath(receiver), 'utf8'));
+        return new Set(Array.isArray(parsed) ? parsed.filter((x) => typeof x === 'string') : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+function saveReadSet(receiver, set) {
+    const target = readMarkerPath(receiver);
+    fs.writeFileSync(`${target}.tmp`, `${JSON.stringify([...set], null, 2)}\n`, 'utf8');
+    fs.renameSync(`${target}.tmp`, target);
+}
+function allMessages() {
+    let files;
+    try {
+        files = fs.readdirSync(busRoot());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        if (!f.endsWith('.json') || f.endsWith('.read.json'))
+            continue;
+        try {
+            out.push(JSON.parse(fs.readFileSync(path.join(busRoot(), f), 'utf8')));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return out.sort((a, b) => (a.createdAt < b.createdAt ? -1 : 1));
+}
+/** 某身份的未读收件箱。 */
+export function inbox(identity = getIdentity()) {
+    const read = getReadSet(identity);
+    return allMessages().filter((m) => m.to === identity && !read.has(m.id));
+}
+/** 标记消息已读（ack）。只能 ack 发给自己的消息。 */
+export function markRead(ids, identity = getIdentity()) {
+    const read = getReadSet(identity);
+    const mine = new Set(allMessages()
+        .filter((m) => m.to === identity)
+        .map((m) => m.id));
+    const marked = [];
+    for (const id of ids) {
+        if (mine.has(id) && !read.has(id)) {
+            read.add(id);
+            marked.push(id);
+        }
+    }
+    if (marked.length)
+        saveReadSet(identity, read);
+    return marked;
+}
+/** 与某身份相关的全部消息（发出或收到），按时间排序。 */
+export function messageHistory(identity = getIdentity()) {
+    return allMessages().filter((m) => m.from === identity || m.to === identity);
+}

package/dist/bots/cli.js

@@ -0,0 +1,102 @@
+// `mocode bots …` 管理：
+//   add --name <n> (--prompt "<text>" | --prompt-file <path>) [--description <d>]
+//       [--tools "a,b,c"] [--sandbox-path <p>] [--global]
+//   list | show <name> | rm <name> [--global]
+// 作用域默认项目（.mocode/bots）；--global 写 ~/.mocode/bots。
+import fs from 'node:fs';
+import { saveBot, listBots, getBot, deleteBot } from './store.js';
+function flagValue(args, flag) {
+    const i = args.indexOf(flag);
+    if (i === -1)
+        return undefined;
+    const v = args[i + 1];
+    return v && !v.startsWith('-') ? v : undefined;
+}
+export async function runBotsCli(rawArgs) {
+    const sub = rawArgs[0] ?? 'list';
+    const args = rawArgs.slice(1);
+    switch (sub) {
+        case 'add': {
+            const name = flagValue(args, '--name');
+            const description = flagValue(args, '--description') ?? '';
+            const inline = flagValue(args, '--prompt');
+            const promptFile = flagValue(args, '--prompt-file');
+            const toolsRaw = flagValue(args, '--tools');
+            const sandboxPath = flagValue(args, '--sandbox-path');
+            const scope = args.includes('--global') ? 'global' : 'project';
+            if (!name) {
+                process.stderr.write('usage: mocode bots add --name <n> (--prompt "<text>" | --prompt-file <path>) ' +
+                    '[--description <d>] [--tools "a,b"] [--sandbox-path <p>] [--global]\n');
+                return 1;
+            }
+            let systemPrompt = inline ?? '';
+            if (promptFile) {
+                try {
+                    systemPrompt = fs.readFileSync(promptFile, 'utf8');
+                }
+                catch (e) {
+                    process.stderr.write(`mocode: cannot read prompt file: ${e instanceof Error ? e.message : String(e)}\n`);
+                    return 1;
+                }
+            }
+            if (!systemPrompt.trim()) {
+                process.stderr.write('mocode: bot prompt is empty (use --prompt or --prompt-file)\n');
+                return 1;
+            }
+            const tools = toolsRaw
+                ? toolsRaw
+                    .split(',')
+                    .map((t) => t.trim())
+                    .filter(Boolean)
+                : undefined;
+            try {
+                const rec = saveBot({ name, description, systemPrompt, tools, sandboxPath, scope });
+                process.stdout.write(`Bot saved: ${rec.name} (${rec.scope})\n`);
+                return 0;
+            }
+            catch (e) {
+                process.stderr.write(`mocode: ${e instanceof Error ? e.message : String(e)}\n`);
+                return 1;
+            }
+        }
+        case 'show': {
+            const name = args[0];
+            if (!name) {
+                process.stderr.write('usage: mocode bots show <name>\n');
+                return 1;
+            }
+            const rec = getBot(name);
+            if (!rec) {
+                process.stderr.write(`mocode: bot "${name}" not found\n`);
+                return 1;
+            }
+            process.stdout.write(`${JSON.stringify(rec, null, 2)}\n`);
+            return 0;
+        }
+        case 'rm':
+        case 'remove': {
+            const name = args[0];
+            if (!name) {
+                process.stderr.write('usage: mocode bots rm <name> [--global]\n');
+                return 1;
+            }
+            const scope = args.includes('--global') ? 'global' : 'project';
+            const ok = deleteBot(name, scope);
+            process.stdout.write(ok ? `Removed bot ${name} (${scope})\n` : `mocode: bot ${name} (${scope}) not found\n`);
+            return ok ? 0 : 1;
+        }
+        case 'list':
+        default: {
+            const all = listBots();
+            if (all.length === 0) {
+                process.stdout.write('(no bots; create one with `mocode bots add …`)\n');
+                return 0;
+            }
+            for (const b of all) {
+                process.stdout.write(`${b.scope === 'global' ? 'g' : 'p'} ${b.name}` +
+                    `${b.tools && b.tools.length ? `  tools:${b.tools.length}` : ''}  ${b.description}\n`);
+            }
+            return 0;
+        }
+    }
+}

package/dist/bots/store.js

@@ -0,0 +1,100 @@
+// 具名 Bot 存储：一个 Bot = 岗位系统提示 + 可选工具白名单 + 可选沙箱范围。
+//
+// 两级存储（与 AGENTS.md 发现规则同风格）：
+// - 全局：~/.mocode/bots/<name>.json
+// - 项目：<sandboxRoot>/.mocode/bots/<name>.json
+// 合并时全局先、项目后，项目同名覆盖全局。
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getSandboxRoot } from '../sandbox/index.js';
+const NAME_RE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+export function globalBotsDir() {
+    return path.join(os.homedir(), '.mocode', 'bots');
+}
+export function projectBotsDir() {
+    return path.join(getSandboxRoot() ?? process.cwd(), '.mocode', 'bots');
+}
+function botPath(dir, name) {
+    return path.join(dir, `${name}.json`);
+}
+function assertValidName(name) {
+    if (!NAME_RE.test(name)) {
+        throw new Error(`bad bot name "${name}": use 1-32 chars, lowercase letters/digits/dash, cannot start with dash`);
+    }
+}
+/** 校验并落盘一个 bot（scope 决定写全局还是项目）。 */
+export function saveBot(input) {
+    assertValidName(input.name);
+    if (!input.systemPrompt.trim())
+        throw new Error('bot systemPrompt must not be empty');
+    const scope = input.scope ?? 'project';
+    const record = {
+        name: input.name,
+        description: input.description ?? '',
+        systemPrompt: input.systemPrompt,
+        ...(input.tools && input.tools.length ? { tools: input.tools } : {}),
+        ...(input.sandboxPath ? { sandboxPath: input.sandboxPath } : {}),
+        scope,
+        createdAt: new Date().toISOString(),
+    };
+    const dir = scope === 'global' ? globalBotsDir() : projectBotsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const target = botPath(dir, record.name);
+    const tmp = `${target}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
+    fs.renameSync(tmp, target);
+    return record;
+}
+function readOne(dir, file) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readDir(dir) {
+    let files;
+    try {
+        files = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        if (!f.endsWith('.json'))
+            continue;
+        const rec = readOne(dir, f);
+        if (rec)
+            out.push(rec);
+    }
+    return out;
+}
+/** 列出全部 bot（全局 + 项目，项目同名覆盖）。 */
+export function listBots() {
+    const byName = new Map();
+    for (const b of readDir(globalBotsDir()))
+        byName.set(b.name, b);
+    for (const b of readDir(projectBotsDir()))
+        byName.set(b.name, b);
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getBot(name) {
+    // 项目优先（覆盖语义）：先找项目再找全局。
+    const project = readOne(projectBotsDir(), `${name}.json`);
+    if (project)
+        return project;
+    return readOne(globalBotsDir(), `${name}.json`);
+}
+export function deleteBot(name, scope = 'project') {
+    assertValidName(name);
+    try {
+        fs.rmSync(botPath(scope === 'global' ? globalBotsDir() : projectBotsDir(), name));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config/index.js

@@ -618,6 +618,7 @@ export const config = {
     llmKeysFromShell,
     permissionEnabled: process.env.MOCODE_PERMISSION !== 'false',
     permissionNonInteractiveAllow: process.env.MOCODE_PERMISSION_NON_INTERACTIVE_ALLOW === 'true',
+    notifyWebhook: process.env.MOCODE_NOTIFY_WEBHOOK || undefined,
 };
 /**
  * 创建一份独立 Config 快照，不重新读取环境变量、配置文件或 preset。