mocode-ai 1.7.1 → 1.7.4

package/README.md

@@ -63,7 +63,7 @@ The implementation is defined by [budget accounting](src/context/budget.ts) and
 
 ### Multi-agent work in a shared workspace
 
-Sub-agents keep independent history branches, can reuse the parent's conversation prefix, and cannot expand beyond the tool set delegated by the parent step. Consecutive sub-agent calls run in bounded parallel batches (`SUB_AGENT_CONCURRENCY`, default `5`; set `1` for sequential dispatch).
+Sub-agents keep independent history branches, can reuse the parent's conversation prefix, and cannot expand beyond the tool set delegated by the parent step. Consecutive sub-agent calls run in bounded parallel batches (`SUB_AGENT_CONCURRENCY`, default `10`; set `1` for sequential dispatch).
 
 **History isolation is not filesystem isolation.** Sub-agents write directly to the shared workspace and inherit the parent's current rollback turn. There is no private filesystem overlay, per-worker worktree, or post-task ChangeSet merge. Nested tools acquire their own resource locks; supported file edits enforce their own expected-hash checks. These guards do not make an entire multi-step sub-task an isolated transaction. The parent receives the final summary, status, usage, and tracked changed files rather than the full worker transcript. Validation remains an explicit agent choice.
 
@@ -225,7 +225,7 @@ Common backend `base_url` values:
 | `MOCODE_LIFECYCLE`              | Provenance metadata tracking; never ages or rewrites content                                  | `true`                      |
 | `MAX_STEPS`                     | Max agent loop steps per turn (infinite-loop safety only)                                     | `1000`                      |
 | `SUB_AGENT_MAX_STEPS`           | Sub-agent loop safety ceiling; defaults to the main-agent value                               | `1000`                      |
-| `SUB_AGENT_CONCURRENCY`         | Concurrent sub-agent calls per dispatch batch; `1` dispatches them sequentially               | `5`                         |
+| `SUB_AGENT_CONCURRENCY`         | Concurrent sub-agent calls per dispatch batch; `1` dispatches them sequentially               | `10`                        |
 | `SUB_AGENT_MAX_DEPTH`           | Maximum recursive delegation depth                                                            | `3`                         |
 | `SANDBOX_ROOT`                  | Sandbox root directory (file operation boundary; falls back to cwd if unset)                  | none                        |
 | `MOCODE_SUBAGENT_ENABLED`       | Set `false` to veto the `orchestration` route group; unset/`true` allows on-demand routing    | unset                       |

package/README.zh-CN.md

@@ -54,7 +54,7 @@ MoCode 是一个分层的自治运行时：终端交互层驱动 Agent 内核，
 
 ### 多 Agent 协作：共享工作区，有界并发
 
-子 agent 维护独立历史分支，可以复用父级对话前缀，工具能力不能超出父 step 委派的范围。连续的子 agent 调用按并发上限分批执行（`SUB_AGENT_CONCURRENCY` 默认 `5`，设为 `1` 时逐个派发）。
+子 agent 维护独立历史分支，可以复用父级对话前缀，工具能力不能超出父 step 委派的范围。连续的子 agent 调用按并发上限分批执行（`SUB_AGENT_CONCURRENCY` 默认 `10`，设为 `1` 时逐个派发）。
 
 **历史隔离不等于文件系统隔离。** 子 agent 直接写入共享工作区，并继承父级当前轮次的回滚记录；没有私有文件系统 overlay、每个 worker 独立的 worktree，也没有任务结束后的 ChangeSet 合并阶段。嵌套工具各自获取资源锁，支持的文件编辑各自执行 expected hash 校验；这些保护不意味着整个多步子任务具备事务隔离。主线接收最终摘要、状态、用量和已追踪的改动文件，而不是完整的子任务过程记录。是否验证及验证范围仍由 agent 自主决定。
 
@@ -224,7 +224,7 @@ LLM_MODEL=glm-4.6                              # 换成你的模型名
 | `MOCODE_LIFECYCLE`              | 只维护 provenance 元数据，不按次数改写正文                                   | `true`                      |
 | `MAX_STEPS`                     | 每轮 Agent 循环最大步数（仅防无限循环）                                      | `1000`                      |
 | `SUB_AGENT_MAX_STEPS`           | 子 Agent 循环安全上限，默认与主 Agent 一致                                   | `1000`                      |
-| `SUB_AGENT_CONCURRENCY`         | 每批子 agent 调用的并发上限；设为 `1` 时逐个派发                             | `5`                         |
+| `SUB_AGENT_CONCURRENCY`         | 每批子 agent 调用的并发上限；设为 `1` 时逐个派发                             | `10`                        |
 | `SUB_AGENT_MAX_DEPTH`           | 递归委派深度上限                                                              | `3`                         |
 | `SANDBOX_ROOT`                  | 沙箱根目录(文件操作边界;未配则用 cwd 兜底)                                   | 无                          |
 | `MOCODE_SUBAGENT_ENABLED`       | 设 `false` 硬禁用 `orchestration`；unset/`true` 允许按需路由                 | 未设置                      |

package/dist/config/index.js

@@ -612,7 +612,7 @@ export const config = {
     maxSteps: Number(process.env.MAX_STEPS) || 1000,
     subAgentEnabled: process.env.MOCODE_SUBAGENT_ENABLED === 'true',
     subAgentMaxSteps: Number(process.env.SUB_AGENT_MAX_STEPS) || Number(process.env.MAX_STEPS) || 1000,
-    subAgentConcurrency: Math.max(1, Number(process.env.SUB_AGENT_CONCURRENCY) || 5),
+    subAgentConcurrency: Math.max(1, Number(process.env.SUB_AGENT_CONCURRENCY) || 10),
     subAgentMaxDepth: Math.max(1, Number(process.env.SUB_AGENT_MAX_DEPTH) || 3),
     frontendToolsEnabled: process.env.MOCODE_FRONTEND_TOOLS_ENABLED === 'true',
     computerUseEnabled: process.env.MOCODE_COMPUTER_USE_ENABLED === 'true',

package/dist/config/profiles.js

@@ -18,7 +18,7 @@ export const TOOL_GROUPS = {
     'agent-meta': ['plan_update', 'note_append', 'ask_human', 'use_skill', 'run_skill'],
     web: ['web_search', 'web_fetch'],
     frontend: ['browser', 'screenshot'],
-    computer: ['computer'],
+    computer: ['computer', 'run_flow'],
     memory: [
         'memory_save',
         'memory_search',
@@ -83,7 +83,7 @@ export const TOOL_ROUTE_GROUPS = {
         gateEnv: 'MOCODE_FRONTEND_TOOLS_ENABLED',
     },
     'computer-control': {
-        tools: ['computer'],
+        tools: ['computer', 'run_flow'],
         description: 'Control real desktop applications with mouse, keyboard, scrolling, and visual feedback.',
         gateEnv: 'MOCODE_COMPUTER_USE_ENABLED',
     },

package/dist/flows/cli.js

@@ -0,0 +1,168 @@
+/**
+ * `mocode flow list | show <name> | run <name> [k=v ...] [--window <正则>] [--yes] [--sandbox-root <path>]`
+ * (design-notes/computer-use-rpa.md §5.4)。
+ *
+ * 非交互回放入口:不经过模型、不依赖 REPL。权限语义与 `/flow run` 一致但 fail-closed:
+ *   - 受 Computer Use 总开关否决(MOCODE_COMPUTER_USE_ENABLED=false);
+ *   - 命中敏感审查(secret 参数、敏感文本、删除/发送/支付类目标)的 flow,没有显式 `--yes` 一律拒绝,
+ *     因为这里没有人可以点确认面板;
+ *   - 未命中敏感审查的 flow 直接运行(用户亲手敲了命令,等价于 `/flow run`)。
+ * 退出码:completed 0;handoff / failed / rejected / 被拒绝 1;用户参数错误 2;aborted 130。
+ *
+ * 重模块(computer.ts 及其 UIA/抓屏依赖)经 deps 注入,默认实现只在 run 时动态加载。
+ */
+import { formatFlowRunResult } from './runner.js';
+import { listFlows, loadFlow, summarizeFlow } from './flow.js';
+import { reviewFlowRun } from '../permissions/flow-review.js';
+import { getSandboxRoot, setSandboxRoot } from '../sandbox/root.js';
+export const FLOW_CLI_USAGE = 'Usage: mocode flow list | show <name> | run <name> [param=value ...] [--window <regex>] [--yes] [--sandbox-root <path>]';
+function defaultDeps() {
+    return {
+        out: (s) => void process.stdout.write(s),
+        err: (s) => void process.stderr.write(s),
+        async computerAllowed() {
+            const { isComputerUseRouteAllowed } = await import('../config/index.js');
+            return isComputerUseRouteAllowed();
+        },
+        async run(flow, params, signal, options) {
+            const { runFlowWithComputer } = await import('../tools/builtins/run-flow.js');
+            return runFlowWithComputer(flow, params, signal, options);
+        },
+    };
+}
+/** 解析 run 子命令的参数(纯函数,便于单测)。 */
+export function parseRunArgs(tokens) {
+    const out = { params: {}, yes: false };
+    for (let i = 0; i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok === '--yes' || tok === '-y') {
+            out.yes = true;
+        }
+        else if (tok === '--window') {
+            const re = tokens[++i];
+            if (!re || re.startsWith('--'))
+                return { ...out, error: '--window requires a regular expression' };
+            try {
+                new RegExp(re, 'i');
+            }
+            catch {
+                return { ...out, error: `--window is not a valid regular expression: ${re}` };
+            }
+            out.windowTitleRegex = re;
+        }
+        else if (tok.startsWith('--')) {
+            return { ...out, error: `unknown option ${tok}` };
+        }
+        else if (out.name === undefined) {
+            out.name = tok;
+        }
+        else {
+            const eq = tok.indexOf('=');
+            if (eq <= 0)
+                return { ...out, error: `parameter "${tok}" must look like name=value` };
+            out.params[tok.slice(0, eq)] = tok.slice(eq + 1);
+        }
+    }
+    return out;
+}
+export async function runFlowCli(rawArgs, deps = defaultDeps()) {
+    // 取出 --sandbox-root <path>(与主入口同语义),其余交给子命令。
+    const args = [];
+    let sandboxRoot;
+    for (let i = 0; i < rawArgs.length; i++) {
+        if (rawArgs[i] === '--sandbox-root') {
+            sandboxRoot = rawArgs[++i];
+            if (!sandboxRoot || sandboxRoot.startsWith('--')) {
+                deps.err('mocode flow: --sandbox-root requires a path\n');
+                return 2;
+            }
+        }
+        else {
+            args.push(rawArgs[i]);
+        }
+    }
+    const prevRoot = sandboxRoot !== undefined ? setSandboxRoot(sandboxRoot) : getSandboxRoot();
+    try {
+        return await dispatch(args, deps);
+    }
+    finally {
+        if (sandboxRoot !== undefined)
+            setSandboxRoot(prevRoot);
+    }
+}
+async function dispatch(args, deps) {
+    const sub = (args.shift() ?? '').toLowerCase();
+    if (sub === 'list') {
+        const items = listFlows();
+        if (items.length === 0) {
+            deps.out('No saved flows (.mocode/flows/).\n');
+            return 0;
+        }
+        for (const it of items) {
+            deps.out(`${it.name}  ${it.steps} steps${it.description ? ` · ${it.description}` : ''}\n`);
+        }
+        return 0;
+    }
+    if (sub === 'show') {
+        const name = args[0];
+        if (!name) {
+            deps.err(`${FLOW_CLI_USAGE}\n`);
+            return 2;
+        }
+        const loaded = loadFlow(name);
+        if (!loaded.ok) {
+            deps.err(`mocode flow: ${loaded.error}\n`);
+            return 1;
+        }
+        deps.out(`${summarizeFlow(loaded.flow)}\n${loaded.path}\n`);
+        return 0;
+    }
+    if (sub === 'run') {
+        const parsed = parseRunArgs(args);
+        if (parsed.error || !parsed.name) {
+            deps.err(`mocode flow: ${parsed.error ?? 'missing flow name'}\n${FLOW_CLI_USAGE}\n`);
+            return 2;
+        }
+        if (!(await deps.computerAllowed())) {
+            deps.err('mocode flow: Computer Use is disabled (MOCODE_COMPUTER_USE_ENABLED=false); flows will not run.\n');
+            return 1;
+        }
+        const loaded = loadFlow(parsed.name);
+        if (!loaded.ok) {
+            deps.err(`mocode flow: ${loaded.error}\n`);
+            return 1;
+        }
+        const review = reviewFlowRun({
+            name: parsed.name,
+            params: parsed.params,
+            ...(parsed.windowTitleRegex ? { window_title_regex: parsed.windowTitleRegex } : {}),
+        });
+        if (review.reasons.length > 0 && !parsed.yes) {
+            deps.err(`mocode flow: flow "${parsed.name}" needs explicit approval and there is no interactive prompt here:\n` +
+                `${review.reasons.map((r) => `  - ${r}`).join('\n')}\n` +
+                'Review it with `mocode flow show`, then re-run with --yes to confirm.\n');
+            return 1;
+        }
+        const controller = new AbortController();
+        const onSigint = () => controller.abort();
+        process.once('SIGINT', onSigint);
+        let result;
+        try {
+            result = await deps.run(loaded.flow, parsed.params, controller.signal, {
+                ...(parsed.windowTitleRegex ? { windowTitleRegex: parsed.windowTitleRegex } : {}),
+            });
+        }
+        finally {
+            process.removeListener('SIGINT', onSigint);
+        }
+        const text = formatFlowRunResult(loaded.flow, result);
+        if (result.status === 'completed') {
+            deps.out(`${text}\n`);
+            return 0;
+        }
+        deps.err(`${text}\n`);
+        return result.status === 'aborted' ? 130 : 1;
+    }
+    deps.err(`${FLOW_CLI_USAGE}\n`);
+    return 2;
+}