mocode-ai 1.6.4 → 1.6.6

package/dist/headless.js

@@ -0,0 +1,302 @@
+// Headless（一次性 / 非交互）模式：mocode -p "任务" 或 echo "任务" | mocode。
+// 与 REPL 共用同一套装配（builtins 工具包 + MCP + runAgentCore），区别只在展示：
+// 没有全屏 TUI，正文流式写 stdout，进度写 stderr（保 stdout 可被管道解析）。
+//
+// 工具进度：默认每个调用打一行「[工具名] 关键参数」（summarizeToolCall，与 TUI
+// 同源；browser fill 等敏感值刻意不显示）。--verbose 追加工具结果摘要。
+//
+// 具名 Bot（C2）：--bot <name> 时用 Bot 的岗位提示作为角色前缀，并按其工具白名单
+// 过滤可调用工具（toolsOverride + runtimeAllowedToolNames，schema 即上限）。
+//
+// 隔离：--session-dir <path> 会话独立目录；--worktree 在 git detached worktree 中
+// 执行并自动销毁。两者走独立 Runtime（不碰全局单例）。
+//
+// 权限：非交互默认 fail-closed（permissions/index.ts 的 !isTTY 分支）。
+// --dangerously-skip-permissions 显式关闭权限闸。
+import path from 'node:path';
+import { setSandboxRoot } from './sandbox/root.js';
+import { registerToolsExtension } from './tools/registry.js';
+// 装配官方默认工具包：registry 不顶层 import builtins（破模块循环），入口须显式装配。
+import './tools/builtins/index.js';
+import { initializeAllMcp, getMcpTools, closeAllMcp } from './mcp/index.js';
+import { config, buildBasePrompt, isMemoryEnabled } from './config/index.js';
+import { effectiveSystemPrompt } from './skills/index.js';
+import { buildMemoryIndexSection } from './memory/store.js';
+import { defaultRuntime, Runtime } from './runtime/index.js';
+import { runAgentCore } from './agent/core.js';
+import { summarizeToolCall, summarizeToolResult } from './ui/render.js';
+import { getToolChatSchema } from './tools/policy.js';
+import { createWorktree, removeWorktree } from './jobs/worktree.js';
+import { runAsIdentity } from './bots/bus.js';
+import { createAsyncApprovalChecker } from './jobs/approval.js';
+import { writeCheckpoint, readCheckpoint } from './jobs/checkpoint.js';
+import { getBot } from './bots/store.js';
+/** 读取 stdin 全部内容作为 prompt（管道场景）。 */
+async function readStdin() {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    for await (const chunk of process.stdin)
+        data += chunk;
+    return data;
+}
+/**
+ * 解析 Bot：查记录、解析其沙箱范围、校验白名单。
+ * 返回 null 表示未使用 Bot；找不到 Bot 抛错（不静默用默认身份，避免误以为岗位生效）。
+ */
+function resolveBot(botName, baseSandbox) {
+    if (!botName)
+        return null;
+    const bot = getBot(botName);
+    if (!bot)
+        throw new Error(`bot "${botName}" not found (project .mocode/bots or global ~/.mocode/bots)`);
+    let sandboxRoot = baseSandbox;
+    if (bot.sandboxPath) {
+        // project bot 相对其工作区；global bot 相对当前 cwd。
+        const anchor = bot.scope === 'project' ? baseSandbox : process.cwd();
+        sandboxRoot = path.resolve(anchor, bot.sandboxPath);
+    }
+    return { bot, sandboxRoot };
+}
+/** 从工具目录按白名单构造 schema 集 + 允许名集合。 */
+function buildBotToolFilter(catalog, allowNames) {
+    const wanted = new Set(allowNames);
+    const toolsOverride = catalog
+        .filter((t) => wanted.has(t.name))
+        .map((t) => getToolChatSchema(t.name, catalog))
+        .filter((s) => s !== null);
+    return { toolsOverride, allowed: new Set(toolsOverride.map((s) => s.function.name)) };
+}
+export async function runHeadless(opts) {
+    const prompt = (opts.prompt ?? '').trim();
+    if (!prompt) {
+        process.stderr.write('mocode: empty prompt (use -p "..." or pipe via stdin)\n');
+        return 1;
+    }
+    if (opts.skipPermissions)
+        config.permissionEnabled = false;
+    // worktree 先建（失败明确报错，不静默回退主工作区）。
+    let wt = null;
+    if (opts.worktree) {
+        try {
+            wt = createWorktree();
+        }
+        catch (e) {
+            process.stderr.write(`mocode: worktree setup failed: ${e instanceof Error ? e.message : String(e)}\n`);
+            return 1;
+        }
+    }
+    const initialSandbox = wt?.path ?? opts.sandboxRootOverride ?? config.sandboxRoot ?? process.cwd();
+    // Bot 解析（在选沙箱之后：bot.sandboxPath 可进一步收窄）。
+    let botInfo;
+    try {
+        botInfo = resolveBot(opts.botName, initialSandbox);
+    }
+    catch (e) {
+        if (wt) {
+            try {
+                removeWorktree(wt);
+            }
+            catch {
+                // ignore
+            }
+        }
+        process.stderr.write(`mocode: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    const effectiveSandboxRoot = botInfo?.sandboxRoot ?? initialSandbox;
+    const isolated = wt !== null || opts.sessionDir !== undefined || opts.jobId !== undefined;
+    // MCP 先初始化注册：独立 Runtime 创建时复制当前 builtinTools（含 MCP），须早于 new Runtime。
+    await initializeAllMcp();
+    registerToolsExtension('mcp', getMcpTools());
+    let runtime;
+    if (isolated) {
+        runtime = new Runtime({
+            sandboxRoot: effectiveSandboxRoot,
+            ...(opts.sessionDir ? { configOverrides: { sessionDir: path.resolve(opts.sessionDir) } } : {}),
+            // bg job：注入异步审批 checker（命中需授权动作时挂起，等 mocode approve）。
+            ...(opts.jobId
+                ? {
+                    services: {
+                        checkPermission: createAsyncApprovalChecker({
+                            jobId: opts.jobId,
+                            sandboxRoot: effectiveSandboxRoot,
+                            getPrompt: () => prompt,
+                        }),
+                    },
+                }
+                : {}),
+        });
+    }
+    else {
+        setSandboxRoot(effectiveSandboxRoot);
+        runtime = defaultRuntime;
+    }
+    await runtime.start();
+    const sessionId = runtime.session.create();
+    // Bot 工具白名单：从该 runtime 实际工具目录过滤。
+    let toolFilter = null;
+    if (botInfo?.bot.tools && botInfo.bot.tools.length) {
+        toolFilter = buildBotToolFilter(runtime.context.toolRuntime.tools, botInfo.bot.tools);
+        if (toolFilter.toolsOverride.length === 0) {
+            process.stderr.write('mocode: bot tool whitelist matched no available tools\n');
+            await runtime.close();
+            if (wt) {
+                try {
+                    removeWorktree(wt);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            return 1;
+        }
+    }
+    // 系统提示：Bot 岗位角色在前，基础约定在后；白名单存在时补一句工具边界。
+    const baseConventions = buildBasePrompt(sessionId) + buildMemoryIndexSection(isMemoryEnabled());
+    const systemContent = botInfo
+        ? `# Role\n${botInfo.bot.systemPrompt}\n\n` +
+            `${botInfo.bot.description ? `**Position:** ${botInfo.bot.description}\n\n` : ''}` +
+            `---\n\n${baseConventions}` +
+            (toolFilter ? `\n\n## Tool boundary\nOnly these tools are available: ${[...toolFilter.allowed].join(', ')}.` : '')
+        : baseConventions;
+    const history = [{ role: 'system', content: effectiveSystemPrompt(systemContent) }];
+    let resumedFromCheckpoint = false;
+    if (opts.resumeFromCheckpoint && opts.jobId) {
+        const snap = readCheckpoint(opts.jobId);
+        if (snap && snap.length) {
+            history.length = 0;
+            history.push(...snap);
+            resumedFromCheckpoint = true;
+        }
+        else {
+            process.stderr.write('mocode: no checkpoint to resume from\n');
+            await runtime.close();
+            return 1;
+        }
+    }
+    let textBuffer = '';
+    // D3 runaway guard (bg jobs only): hard wall-clock / token caps.
+    let jobSignal;
+    let jobGuard;
+    if (opts.jobId) {
+        const maxMs = Number(process.env.MOCODE_JOB_MAX_MS ?? 0);
+        const maxTokens = Number(process.env.MOCODE_JOB_MAX_TOKENS ?? 0);
+        if (maxMs > 0 || maxTokens > 0) {
+            const controller = new AbortController();
+            const state = { tokens: 0, maxTokens, controller, timer: undefined };
+            if (maxMs > 0)
+                state.timer = setTimeout(() => {
+                    process.stderr.write(`\n[guard] job exceeded ${maxMs}ms; aborting\n`);
+                    controller.abort();
+                }, maxMs);
+            jobGuard = state;
+            jobSignal = controller.signal;
+        }
+    }
+    const hooks = {
+        onLiveUsage: (u) => {
+            if (!jobGuard)
+                return;
+            jobGuard.tokens = Math.max(jobGuard.tokens, u.totalTokens);
+            if (jobGuard.maxTokens && jobGuard.tokens > jobGuard.maxTokens) {
+                process.stderr.write(`\n[guard] job exceeded ${jobGuard.maxTokens} tokens; aborting\n`);
+                jobGuard.controller?.abort();
+            }
+        },
+        onText: (delta) => {
+            textBuffer += delta;
+            if (!opts.json)
+                process.stdout.write(delta);
+        },
+        onToolHeader: (tc) => {
+            if (!opts.json && textBuffer && !textBuffer.endsWith('\n')) {
+                process.stdout.write('\n');
+                textBuffer += '\n';
+            }
+            process.stderr.write(`[${tc.name}] ${summarizeToolCall(tc.name, tc.arguments)}\n`);
+        },
+        onToolResult: (tc, output) => {
+            if (!opts.verbose)
+                return;
+            process.stderr.write(`  → ${summarizeToolResult(tc.name, output)}\n`);
+        },
+        ...(opts.jobId
+            ? {
+                onCheckpoint: (h) => writeCheckpoint(opts.jobId, h),
+            }
+            : {}),
+        onModelRetry: (info) => {
+            process.stderr.write(`[retry] model error (${info.code}), retry ${info.nextAttempt} in ${info.waitMs}ms\n`);
+        },
+    };
+    const startedAt = Date.now();
+    let exitCode = 0;
+    let result;
+    const invokeCore = () => runAgentCore({
+        history,
+        userInput: prompt,
+        hooks,
+        ...(jobSignal ? { signal: jobSignal } : {}),
+        runtimeContext: runtime.context,
+        ...(resumedFromCheckpoint ? { continueFromHistory: true } : {}),
+        ...(toolFilter ? { toolsOverride: toolFilter.toolsOverride, runtimeAllowedToolNames: toolFilter.allowed } : {}),
+    });
+    try {
+        result = opts.botName ? await runAsIdentity(opts.botName, () => invokeCore()) : await invokeCore();
+    }
+    finally {
+        if (jobGuard?.timer)
+            clearTimeout(jobGuard.timer);
+        try {
+            runtime.session.save(history, sessionId, [prompt], []);
+        }
+        catch {
+            // 落盘失败不覆盖主结果
+        }
+        closeAllMcp();
+        await runtime.close();
+        if (wt) {
+            try {
+                removeWorktree(wt);
+            }
+            catch {
+                process.stderr.write(`mocode: failed to remove worktree ${wt.path}（手动清理）\n`);
+            }
+        }
+    }
+    const elapsedMs = Date.now() - startedAt;
+    const finalText = result.finalText ?? (opts.json ? null : textBuffer);
+    if (opts.json) {
+        const payload = {
+            terminationReason: result.terminationReason,
+            text: finalText,
+            sessionId,
+            changedFiles: result.changedFiles ?? [],
+            usage: result.usage,
+            elapsedMs,
+            model: config.model,
+            ...(opts.botName ? { bot: opts.botName } : {}),
+        };
+        process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    }
+    else if (finalText && !textBuffer) {
+        process.stdout.write(finalText);
+    }
+    if (!opts.json && process.stdout.isTTY && finalText && !finalText.endsWith('\n'))
+        process.stdout.write('\n');
+    if (result.terminationReason === 'aborted')
+        exitCode = 130;
+    else if (result.terminationReason === 'max_steps' || !result.completed)
+        exitCode = 1;
+    return exitCode;
+}
+/** 无 -p 且 stdin 被重定向时，从 stdin 取 prompt；返回 null 表示无可用输入。 */
+export async function resolvePrompt(inlinePrompt) {
+    if (inlinePrompt !== undefined)
+        return inlinePrompt;
+    if (!process.stdin.isTTY) {
+        const piped = (await readStdin()).trim();
+        return piped || null;
+    }
+    return null;
+}

package/dist/index.js

@@ -38,10 +38,26 @@ process.on('unhandledRejection', (e) => {
     exitAltScreen();
     process.exit(1);
 });
+/** 取 args 中任意位置的非 flag 参数；排除带值 flag（--sandbox-root）的下一个值。 */
+function firstPositional(args, options = {}) {
+    const valueFlags = options.valueFlags ?? [];
+    return args.find((a, idx) => {
+        if (a.startsWith('-'))
+            return false;
+        if (valueFlags.includes(args[idx - 1] ?? ''))
+            return false;
+        return true;
+    });
+}
 /**
- * 入口:装配并启动 REPL。支持 --resume <id> 续接历史会话(裸 --resume 列出会话)。
+ * 入口:
+ * - 后台任务:`mocode run --bg "任务"`（detached 子进程，状态落 .mocode/jobs/）。
+ * - Job runner 内部模式:`mocode --job-runner <id>`（由 run --bg 派生，用户不直接用）。
+ * - Headless（一次性 / 非交互）:`mocode -p "任务"` 或 `echo "任务" | mocode`，
+ *   可选 --json / --verbose / --dangerously-skip-permissions。
+ * - 交互 REPL（默认）;支持 --resume <id> 续接历史会话(裸 --resume 列出会话)。
  * `mocode config` 走首跑配置向导(动态加载 commands/config,不引入 REPL/config 图,故缺配置也能跑)。
- * REPL / session 用动态 import 按需加载——只在真正启动时才拉入 config 依赖图。
+ * REPL / session / headless / jobs 用动态 import 按需加载——只在真正启动时才拉入 config 依赖图。
  * 显式 process.exit(0)——OpenAI 客户端的 keep-alive 会卡住事件循环。
  */
 async function main() {
@@ -58,12 +74,160 @@ async function main() {
             process.exit(1);
         }
     }
+    // --session-dir <path>:会话独立落盘目录(不写主 .mocode/sessions)。
+    const sd = args.indexOf('--session-dir');
+    let sessionDirOverride;
+    if (sd !== -1) {
+        sessionDirOverride = args[sd + 1];
+        if (!sessionDirOverride || sessionDirOverride.startsWith('--')) {
+            console.error('mocode: --session-dir requires a path');
+            process.exit(1);
+        }
+    }
+    const useWorktree = args.includes('--worktree');
+    const botFlagIdx = args.indexOf('--bot');
+    const botName = botFlagIdx !== -1 ? args[botFlagIdx + 1] : undefined;
     // 首跑配置向导:写 ~/.mocode/config。独立模块,不触发 config 校验,故零配置也能跑。
+    if (args[0] === 'bots') {
+        const { runBotsCli } = await import('./bots/cli.js');
+        const code = await runBotsCli(args.slice(1));
+        process.exit(code);
+    }
+    if (args[0] === 'schedule') {
+        const { runScheduleCli } = await import('./schedule/cli.js');
+        const code = await runScheduleCli(args.slice(1));
+        process.exit(code);
+    }
+    if (args[0] === 'resume-job') {
+        const { resumeBackgroundJob } = await import('./jobs/launch.js');
+        const rec = resumeBackgroundJob(args[1] ?? '');
+        if (!rec) {
+            process.stderr.write('mocode: job not found\n');
+            process.exit(1);
+        }
+        process.stdout.write(`Resumed ${rec.id} from last checkpoint.\n`);
+        process.exit(0);
+    }
+    if (args[0] === 'attach') {
+        const { runAttachCli } = await import('./jobs/attach.js');
+        const code = await runAttachCli(args.slice(1));
+        await shutdownRuntime();
+        process.exit(code);
+    }
+    if (args[0] === 'approve' || args[0] === 'deny') {
+        const { runApproveCli } = await import('./jobs/approve-cli.js');
+        const code = runApproveCli(args.slice(1), args[0] === 'approve' ? 'approved' : 'denied');
+        process.exit(code);
+    }
     if (args[0] === 'config') {
         const { runConfigWizard } = await import('./commands/config.js');
         await runConfigWizard();
         process.exit(0);
     }
+    // Job runner 内部模式：detached 子进程入口。
+    const runnerIdx = args.indexOf('--job-runner');
+    if (runnerIdx !== -1) {
+        const jobId = args[runnerIdx + 1];
+        if (!jobId) {
+            process.stderr.write('mocode: --job-runner requires a job id\n');
+            process.exit(1);
+        }
+        const { isModelConfigured } = await import('./config/index.js');
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured; cannot run background job.\n');
+            process.exit(1);
+        }
+        const { runJobRunner } = await import('./jobs/runner.js');
+        const code = await runJobRunner(jobId, args.includes('--resume'));
+        process.exit(code);
+    }
+    // 调度守护进程内部模式：detached 进程入口。
+    const schedDaemonIdx = args.indexOf('--schedule-daemon');
+    if (schedDaemonIdx !== -1) {
+        const portIdx = args.indexOf('--port');
+        const port = portIdx !== -1 ? Number(args[portIdx + 1]) : undefined;
+        const { runDaemon } = await import('./schedule/daemon.js');
+        runDaemon(port);
+        return; // 常驻：不显式 exit，detached 进程靠事件循环存活
+    }
+    // 后台任务：mocode run [--bg] "任务"。
+    if (args[0] === 'run') {
+        const rest = args.slice(1);
+        const background = rest.includes('--bg');
+        const prompt = firstPositional(rest, { valueFlags: ['--sandbox-root'] });
+        const { isModelConfigured } = await import('./config/index.js');
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured. Set LLM_BASE_URL / LLM_API_KEY / LLM_MODEL ' +
+                '(or run `mocode config`) first.\n');
+            process.exit(1);
+        }
+        if (background) {
+            const { launchBackgroundJob } = await import('./jobs/launch.js');
+            const { resolvePrompt } = await import('./headless.js');
+            const resolved = await resolvePrompt(prompt);
+            if (!resolved) {
+                process.stderr.write('mocode: empty task (use `mocode run --bg "task"` or pipe via stdin)\n');
+                process.exit(1);
+            }
+            const { record } = launchBackgroundJob(resolved, {
+                ...(sessionDirOverride ? { sessionDir: sessionDirOverride } : {}),
+                ...(useWorktree ? { worktree: true } : {}),
+                ...(botName ? { botName } : {}),
+            });
+            process.stdout.write(`Job started: ${record.id}\n  pid: ${record.pid ?? '?'}\n  log: ${record.logPath}\n` +
+                `  track with: mocode /jobs (in TUI) or read the log file\n`);
+            process.exit(0);
+        }
+        // 前台 run：等价 -p，走 headless。
+        const { runHeadless, resolvePrompt } = await import('./headless.js');
+        const resolved = await resolvePrompt(prompt);
+        if (!resolved) {
+            process.stderr.write('mocode: empty task\n');
+            process.exit(1);
+        }
+        const code = await runHeadless({
+            prompt: resolved,
+            json: rest.includes('--json'),
+            verbose: rest.includes('--verbose'),
+            skipPermissions: rest.includes('--dangerously-skip-permissions'),
+            sandboxRootOverride,
+            sessionDir: sessionDirOverride,
+            worktree: useWorktree,
+            ...(botName ? { botName } : {}),
+        });
+        await shutdownRuntime();
+        process.exit(code);
+    }
+    // Headless：-p / --print [prompt]。prompt 缺省时从 stdin（管道）读取。
+    const printIdx = args.findIndex((a) => a === '-p' || a === '--print');
+    if (printIdx !== -1) {
+        // 任意位置的非 flag 参数都作为 prompt（不要求紧跟 -p）；排除 --sandbox-root 的值。
+        const inlinePrompt = firstPositional(args.filter((_, idx) => idx !== printIdx), { valueFlags: ['--sandbox-root'] });
+        const { runHeadless, resolvePrompt } = await import('./headless.js');
+        const { isModelConfigured } = await import('./config/index.js');
+        const prompt = await resolvePrompt(inlinePrompt);
+        if (!prompt) {
+            process.stderr.write('mocode: empty prompt (use -p "..." or pipe via stdin)\n');
+            process.exit(1);
+        }
+        if (!isModelConfigured()) {
+            process.stderr.write('mocode: model not configured. Set LLM_BASE_URL / LLM_API_KEY / LLM_MODEL ' +
+                '(or run `mocode config`) before using -p.\n');
+            process.exit(1);
+        }
+        const exitCode = await runHeadless({
+            prompt,
+            json: args.includes('--json'),
+            verbose: args.includes('--verbose'),
+            skipPermissions: args.includes('--dangerously-skip-permissions'),
+            sandboxRootOverride,
+            sessionDir: sessionDirOverride,
+            worktree: useWorktree,
+            ...(botName ? { botName } : {}),
+        });
+        await shutdownRuntime();
+        process.exit(exitCode);
+    }
     const i = args.indexOf('--resume');
     if (i !== -1) {
         const { listSessions, loadSession } = await import('./session/index.js');
@@ -97,4 +261,8 @@ async function main() {
     await shutdownRuntime();
     process.exit(0);
 }
-main();
+main().catch((e) => {
+    exitAltScreen();
+    process.stderr.write(`${e instanceof Error ? e.stack || e.message : String(e)}\n`);
+    process.exit(1);
+});

package/dist/jobs/approval.js

@@ -0,0 +1,153 @@
+// 异步审批（park-and-wait）：bg 任务在非 TTY 下需要授权时，不 fail-closed 拒绝，
+// 而是——
+//   1. 写 <jobId>.approval.json 请求（含工具名/参数摘要）；
+//   2. job 记录置 paused，发通知（MOCODE_NOTIFY_WEBHOOK）；
+//   3. 进程挂起，每 1.5s 轮询 <jobId>.approval.decision；
+//   4. `mocode approve <jobId>` 写决定 → checker 在同进程内返回 allow，
+//      agent 带着完整内存历史继续，无需序列化。
+//
+// 已知限制：等待依赖进程存活；机器重启 / 进程被杀则需重新发起（v1 不做断点重放）。
+// MOCODE_APPROVAL_TIMEOUT_MS 可设最大等待（默认 0 = 一直等），超时按 deny。
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config/index.js';
+import { createPermissionChecker } from '../permissions/index.js';
+import { sendNotification } from '../notify/index.js';
+import { jobsRoot, updateJob } from './store.js';
+function requestPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.approval.json`);
+}
+function decisionPath(jobId) {
+    return path.join(jobsRoot(), `${jobId}.approval.decision`);
+}
+function argsPreview(tool, args) {
+    if (tool === 'run_command' && typeof args.command === 'string')
+        return args.command.slice(0, 200);
+    if (typeof args.path === 'string')
+        return String(args.path);
+    if (typeof args.url === 'string')
+        return String(args.url);
+    try {
+        return JSON.stringify(args).slice(0, 200);
+    }
+    catch {
+        return '(unserializable args)';
+    }
+}
+function writeApprovalRequest(jobId, tool, args, prompt) {
+    fs.mkdirSync(jobsRoot(), { recursive: true });
+    const payload = {
+        jobId,
+        tool,
+        argsPreview: argsPreview(tool, args),
+        prompt,
+        createdAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(requestPath(jobId), `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+export function hasPendingApproval(jobId) {
+    try {
+        fs.accessSync(requestPath(jobId));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** 挂起轮询，直到外部写决定文件；消费后清理请求/决定文件。 */
+async function awaitDecision(jobId) {
+    const dp = decisionPath(jobId);
+    const maxMs = Number(process.env.MOCODE_APPROVAL_TIMEOUT_MS ?? 0);
+    const startedAt = Date.now();
+    for (;;) {
+        try {
+            const v = fs.readFileSync(dp, 'utf8').trim();
+            if (v === 'approved' || v === 'denied') {
+                try {
+                    fs.rmSync(dp);
+                    fs.rmSync(requestPath(jobId));
+                }
+                catch {
+                    // cleanup best-effort
+                }
+                return v;
+            }
+        }
+        catch {
+            // 决定文件尚未出现
+        }
+        if (maxMs > 0 && Date.now() - startedAt > maxMs) {
+            try {
+                fs.rmSync(requestPath(jobId));
+            }
+            catch {
+                // ignore
+            }
+            return 'denied';
+        }
+        await sleep(1500);
+    }
+}
+/**
+ * 异步审批 checker：包正常 checker，命中“需授权”时挂起等待。
+ * 一旦批准，jobApproved=true → 本次运行后续动作不再逐个询问（语义：批准这个任务）。
+ */
+export function createAsyncApprovalChecker(deps) {
+    const inner = createPermissionChecker(config, deps.sandboxRoot);
+    let jobApproved = false;
+    return async (tool, args, signal, options) => {
+        if (jobApproved)
+            return 'allow';
+        const decision = await inner(tool, args, signal, options);
+        if (decision === 'allow')
+            return 'allow';
+        // 需要授权：置 paused + 写请求 + 通知，然后挂起。
+        updateJob(deps.jobId, { status: 'paused' }, { force: true });
+        writeApprovalRequest(deps.jobId, tool.name, args, deps.getPrompt());
+        await sendNotification(config.notifyWebhook, {
+            status: 'waiting',
+            tool: tool.name,
+            prompt: deps.getPrompt(),
+            sessionId: deps.jobId,
+            elapsedMs: 0,
+            model: config.model,
+        });
+        const result = await awaitDecision(deps.jobId);
+        if (result === 'approved') {
+            jobApproved = true;
+            updateJob(deps.jobId, { status: 'running' }, { force: true });
+            return 'allow';
+        }
+        return 'deny';
+    };
+}
+/** CLI/TUI 批准或拒绝：写决定文件。无挂起请求时报错。 */
+export function approveJob(jobId, decision) {
+    if (!hasPendingApproval(jobId))
+        return { ok: false, reason: 'no pending approval for this job' };
+    fs.writeFileSync(decisionPath(jobId), decision, 'utf8');
+    return { ok: true };
+}
+/** 列出所有挂起的审批请求。 */
+export function listPendingApprovals() {
+    let files;
+    try {
+        files = fs.readdirSync(jobsRoot());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const f of files) {
+        if (!f.endsWith('.approval.json'))
+            continue;
+        try {
+            out.push(JSON.parse(fs.readFileSync(path.join(jobsRoot(), f), 'utf8')));
+        }
+        catch {
+            // skip corrupt
+        }
+    }
+    return out;
+}

package/dist/jobs/approve-cli.js

@@ -0,0 +1,30 @@
+// `mocode approve <jobId>` / `mocode deny <jobId>`：写决定文件，唤醒挂起的 bg job。
+import { approveJob, listPendingApprovals } from './approval.js';
+export function runApproveCli(rawArgs, decision) {
+    let id = rawArgs[0];
+    // 无参数：恰好一个挂起审批时自动选中，否则列出全部。
+    if (!id) {
+        const pending = listPendingApprovals();
+        if (pending.length === 1) {
+            id = pending[0]?.jobId;
+        }
+        else {
+            if (pending.length === 0)
+                process.stdout.write('No pending approvals.\n');
+            else {
+                for (const p of pending) {
+                    process.stdout.write(`  ${p.jobId}  ${p.tool}  ${p.argsPreview.split('\n')[0]}\n`);
+                }
+                process.stdout.write('Usage: mocode approve <jobId>\n');
+            }
+            return pending.length === 1 ? 0 : 1;
+        }
+    }
+    const r = approveJob(id, decision);
+    if (!r.ok) {
+        process.stderr.write(`mocode: ${r.reason ?? 'failed'}\n`);
+        return 1;
+    }
+    process.stdout.write(`${decision === 'approved' ? 'Approved' : 'Denied'} ${id}; job continues.\n`);
+    return 0;
+}