mocode-ai 1.7.2 → 1.7.5

package/dist/flows/runner.js

@@ -0,0 +1,259 @@
+import { DEFAULT_ON_ERROR, FLOW_RESERVED_KEYS, describeStep, renderStep, resolveParams, } from './flow.js';
+/** 低于此长度的 secret 不打码(1-2 个字符会把无关文本也替换花)。 */
+const REDACT_MIN_LEN = 3;
+const ERROR_CLIP = 400;
+/** 步骤里的 computer 参数(去掉 flow 保留键)。 */
+function computerArgs(step) {
+    const out = { action: step.action };
+    for (const [k, v] of Object.entries(step))
+        if (!FLOW_RESERVED_KEYS.has(k))
+            out[k] = v;
+    return out;
+}
+/** selector 失败且显式允许时,把元素步骤改写成按录制坐标执行的动作序列。 */
+function coordinateFallbackActions(step) {
+    const coordinate = step.fallback?.coordinate;
+    if (!coordinate)
+        return [];
+    if (step.action === 'click_element') {
+        const button = step.button;
+        const count = step.click_count;
+        let action = 'left_click';
+        if (button === 'right')
+            action = 'right_click';
+        else if (button === 'middle')
+            action = 'middle_click';
+        else if (count === 2)
+            action = 'double_click';
+        else if (count === 3)
+            action = 'triple_click';
+        return [{ action, coordinate }];
+    }
+    if (step.action === 'set_value') {
+        return [
+            { action: 'left_click', coordinate },
+            { action: 'key', text: 'ctrl+a' },
+            { action: 'type', text: typeof step.text === 'string' ? step.text : '' },
+        ];
+    }
+    return [];
+}
+function isElementStep(step) {
+    return step.action === 'click_element' || step.action === 'set_value';
+}
+async function attemptStep(step, deps, windowTitleRegex) {
+    try {
+        let argSets;
+        let note;
+        if (isElementStep(step)) {
+            const selector = step.selector && windowTitleRegex !== undefined
+                ? { ...step.selector, window: { ...step.selector.window, titleRegex: windowTitleRegex } }
+                : step.selector;
+            const located = selector
+                ? await deps.resolveRef(selector, deps.signal)
+                : { ok: false, error: 'this step has no selector' };
+            if (located.ok) {
+                argSets = [{ ...computerArgs(step), ref: located.ref }];
+            }
+            else if (step.allowCoordinateFallback === true && step.fallback) {
+                argSets = coordinateFallbackActions(step);
+                note = `selector failed (${located.error}); used the recorded coordinates`;
+            }
+            else {
+                const hint = step.fallback
+                    ? ' (a recorded coordinate exists, but allowCoordinateFallback is not enabled for this step)'
+                    : '';
+                return {
+                    ok: false,
+                    error: `could not locate the element: ${located.error}${hint}`,
+                    aborted: false,
+                    retryable: true,
+                };
+            }
+        }
+        else if (step.action === 'focus_window') {
+            const win = step.window && windowTitleRegex !== undefined ? { ...step.window, titleRegex: windowTitleRegex } : step.window;
+            if (win?.processName) {
+                const resolved = await deps.resolveWindow(win, deps.signal);
+                if (!resolved.ok)
+                    return { ok: false, error: resolved.error, aborted: false, retryable: true };
+                argSets = [{ ...computerArgs(step), ...resolved.args }];
+            }
+            else if (win?.titleRegex) {
+                argSets = [{ ...computerArgs(step), title_regex: win.titleRegex }];
+            }
+            else {
+                return { ok: false, error: 'focus_window step has no window information', aborted: false, retryable: false };
+            }
+        }
+        else {
+            argSets = [computerArgs(step)];
+        }
+        let last;
+        for (const args of argSets) {
+            last = await deps.execute(args, deps.signal);
+            if (last.status !== 'success')
+                break;
+        }
+        if (!last)
+            return { ok: false, error: 'nothing to execute for this step', aborted: false, retryable: false };
+        if (last.status === 'success')
+            return { ok: true, outcome: last, note };
+        return {
+            ok: false,
+            error: last.output,
+            aborted: last.status === 'aborted',
+            retryable: last.code !== 'TIMEOUT' && last.status !== 'denied' && last.status !== 'aborted',
+            outcome: last,
+        };
+    }
+    catch (error) {
+        const aborted = deps.signal?.aborted === true;
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            aborted,
+            retryable: !aborted,
+        };
+    }
+}
+export async function runFlow(flow, given, deps, options = {}) {
+    const resolved = resolveParams(flow, given);
+    if (!resolved.ok)
+        return { status: 'rejected', steps: [], completed: 0, skipped: 0, error: resolved.error };
+    const values = resolved.values;
+    const secretValues = Object.entries(flow.params)
+        .filter(([, p]) => p.secret)
+        .map(([name]) => values[name])
+        .filter((v) => typeof v === 'string' && v.length >= REDACT_MIN_LEN);
+    const redact = (text) => {
+        let out = text;
+        for (const s of secretValues)
+            out = out.split(s).join('***');
+        return out.length > ERROR_CLIP ? `${out.slice(0, ERROR_CLIP)}…` : out;
+    };
+    const steps = [];
+    let completed = 0;
+    let skipped = 0;
+    let attachments;
+    const finish = (status, failedStep, error) => ({
+        status,
+        steps,
+        completed,
+        skipped,
+        ...(failedStep ? { failedStep } : {}),
+        ...(error ? { error } : {}),
+        ...(attachments ? { attachments } : {}),
+    });
+    for (let i = 0; i < flow.steps.length; i++) {
+        const index = i + 1;
+        if (deps.signal?.aborted)
+            return finish('aborted');
+        const original = flow.steps[i];
+        let step;
+        try {
+            step = renderStep(original, values);
+        }
+        catch (error) {
+            return finish('rejected', undefined, error instanceof Error ? error.message : String(error));
+        }
+        const policy = { ...DEFAULT_ON_ERROR, ...original.onError };
+        const maxAttempts = policy.retry + 1;
+        let attempts = 0;
+        let success;
+        let failure;
+        while (attempts < maxAttempts) {
+            attempts += 1;
+            const r = await attemptStep(step, deps, options.windowTitleRegex);
+            if (r.ok) {
+                success = r;
+                break;
+            }
+            failure = r;
+            if (r.outcome?.modelAttachments?.length)
+                attachments = r.outcome.modelAttachments;
+            if (r.aborted)
+                return finish('aborted');
+            if (!r.retryable || attempts >= maxAttempts)
+                break;
+            try {
+                await deps.sleep(policy.retryDelayMs, deps.signal);
+            }
+            catch {
+                return finish('aborted');
+            }
+            if (deps.signal?.aborted)
+                return finish('aborted');
+        }
+        if (success) {
+            completed += 1;
+            if (success.outcome.modelAttachments?.length)
+                attachments = success.outcome.modelAttachments;
+            steps.push({
+                index,
+                action: original.action,
+                status: 'ok',
+                attempts,
+                ...(success.note ? { detail: redact(success.note) } : {}),
+            });
+            continue;
+        }
+        const error = redact(failure?.error ?? 'unknown error');
+        if (policy.then === 'skip') {
+            skipped += 1;
+            steps.push({ index, action: original.action, status: 'skipped', attempts, detail: error });
+            continue;
+        }
+        steps.push({ index, action: original.action, status: 'failed', attempts, detail: error });
+        return finish(policy.then === 'abort' ? 'failed' : 'handoff', {
+            index,
+            description: describeStep(original, index),
+            error,
+        });
+    }
+    return finish('completed');
+}
+/** 面向模型/用户的结果文本。 */
+export function formatFlowRunResult(flow, r) {
+    const total = flow.steps.length;
+    const skippedLines = r.steps
+        .filter((s) => s.status === 'skipped')
+        .map((s) => `  - step ${s.index} (${s.action}) skipped: ${s.detail ?? 'failed'}`);
+    const noteLines = r.steps
+        .filter((s) => s.status === 'ok' && s.detail)
+        .map((s) => `  - step ${s.index} (${s.action}): ${s.detail}`);
+    switch (r.status) {
+        case 'rejected':
+            return `Flow "${flow.name}" was not run: ${r.error ?? 'invalid parameters'}`;
+        case 'completed': {
+            const lines = [
+                `Flow "${flow.name}" completed: ${r.completed}/${total} steps ran${r.skipped ? `, ${r.skipped} skipped` : ''}. ` +
+                    'The attached screenshot (if any) is the final screen; verify the result.',
+                ...skippedLines,
+                ...noteLines,
+            ];
+            return lines.join('\n');
+        }
+        case 'aborted':
+            return `Flow "${flow.name}" was interrupted after ${r.completed} of ${total} steps.`;
+        case 'failed':
+        case 'handoff': {
+            const f = r.failedStep;
+            const head = r.status === 'handoff'
+                ? `Flow "${flow.name}" stopped at step ${f?.index}/${total} and is handed back to you.`
+                : `Flow "${flow.name}" failed at step ${f?.index}/${total} (onError: abort); no further steps were run.`;
+            const lines = [
+                head,
+                `Step: ${f?.description ?? '(unknown)'}`,
+                `Error: ${f?.error ?? 'unknown'}`,
+                `Completed before the failure: ${r.completed} step(s)${r.skipped ? `, ${r.skipped} skipped` : ''}.`,
+                ...skippedLines,
+                ...noteLines,
+            ];
+            if (r.status === 'handoff') {
+                lines.push('The attached screenshot (if any) shows the current screen. Continue the remaining steps manually with computer actions (inspect first), or fix the flow file and run it again.');
+            }
+            return lines.join('\n');
+        }
+    }
+}

package/dist/flows/trace.js

@@ -0,0 +1,242 @@
+/**
+ * computer 动作的结构化录制(design-notes/computer-use-rpa.md §5.1)。
+ *
+ * 与 session/gui-actions.ts 的区别:台账是给模型看的有损文本(24 条滚动);trace 是给 flow 导出用的
+ * 结构化 JSONL(`gui-trace.jsonl`,同会话目录),元素动作落盘的是 selector 而不是会过期的 ref。
+ *
+ * 契约:
+ *   - 纯函数 buildTraceEntry 不碰盘、不碰屏幕,可用 fixture 单测;
+ *   - 观察类动作(screenshot/zoom/inspect/list_windows/cursor_position)不入 trace;
+ *   - 命中 computerTextNeedsReview 的文本**不落明文**,记为 `{ $param: "text_<seq>" }`,回放时由调用方提供;
+ *   - 写入失败静默:trace 是可观测性,绝不能影响 computer 动作结果。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { computerTextNeedsReview } from '../permissions/computer-review.js';
+import { getSandboxRoot } from '../sandbox/root.js';
+import { getCurrentSessionId } from '../session/state.js';
+import { buildSelector, rectToNorm, } from '../runtime/uia-selector.js';
+export const TRACE_FILENAME = 'gui-trace.jsonl';
+export function isParamRef(v) {
+    return !!v && typeof v === 'object' && typeof v.$param === 'string';
+}
+const KEEP_ARGS = {
+    mouse_move: ['coordinate'],
+    left_click: ['coordinate'],
+    right_click: ['coordinate'],
+    middle_click: ['coordinate'],
+    double_click: ['coordinate'],
+    triple_click: ['coordinate'],
+    left_mouse_down: ['coordinate'],
+    left_mouse_up: ['coordinate'],
+    left_click_drag: ['coordinate', 'coordinate_to'],
+    scroll: ['coordinate', 'scroll_direction', 'scroll_amount'],
+    type: ['text', 'method'],
+    key: ['text'],
+    wait: ['duration_ms'],
+    wait_until: ['condition', 'timeout_ms'],
+    click_element: ['button', 'click_count', 'via'],
+    set_value: ['text', 'via'],
+    focus_window: ['move_to_primary'],
+};
+/** 会入 trace 的动作集合。 */
+export const RECORDED_ACTIONS = new Set(Object.keys(KEEP_ARGS));
+export function isRecordedAction(action) {
+    return RECORDED_ACTIONS.has(action);
+}
+const COORDINATE_ACTIONS = new Set([
+    'mouse_move',
+    'left_click',
+    'right_click',
+    'middle_click',
+    'double_click',
+    'triple_click',
+    'left_mouse_down',
+    'left_mouse_up',
+    'left_click_drag',
+    'scroll',
+]);
+const TEXT_ACTIONS = new Set(['type', 'key', 'set_value']);
+/**
+ * 把一次(即将执行的)computer 调用转成 trace 条目。返回 null = 无法形成可回放的步骤(调用方不记录)。
+ * 必须在执行**前**调用:此时 elementSnapshot / windowSnapshot / ref 登记表还是模型当时所见。
+ */
+export function buildTraceEntry(args, ctx) {
+    const action = typeof args.action === 'string' ? args.action : '';
+    const keep = KEEP_ARGS[action];
+    if (!keep)
+        return null;
+    const out = {};
+    for (const k of keep)
+        if (args[k] !== undefined)
+            out[k] = args[k];
+    const entry = {
+        seq: ctx.seq,
+        ts: ctx.ts ?? new Date().toISOString(),
+        action,
+        args: out,
+    };
+    // 文本:敏感内容不落明文。
+    if (TEXT_ACTIONS.has(action) && typeof out.text === 'string' && computerTextNeedsReview(out.text)) {
+        out.text = { $param: `text_${ctx.seq}` };
+    }
+    if (COORDINATE_ACTIONS.has(action))
+        entry.fragile = true;
+    if (action === 'click_element' || action === 'set_value') {
+        const el = ctx.element;
+        const node = el?.tree.nodes[el.nodeId];
+        if (!el || !node)
+            return null;
+        entry.target = { role: node.role, name: node.name };
+        const selector = buildSelector(el.tree, el.nodeId);
+        if (selector)
+            entry.selector = selector;
+        else
+            entry.fragile = true;
+        if (ctx.geometry) {
+            const [x, y, w, h] = rectToNorm(node.rect, ctx.geometry);
+            entry.fallback = { coordinate: [Math.round(x + w / 2), Math.round(y + h / 2)] };
+        }
+        if (!entry.selector && !entry.fallback)
+            return null;
+    }
+    if (action === 'focus_window') {
+        const titleRegex = typeof args.title_regex === 'string' ? args.title_regex : undefined;
+        if (!ctx.windowProcess && !titleRegex)
+            return null;
+        entry.window = {
+            ...(ctx.windowProcess ? { processName: ctx.windowProcess } : {}),
+            ...(titleRegex ? { titleRegex } : {}),
+        };
+    }
+    if (action === 'wait_until') {
+        const cond = args.condition;
+        if (!cond || typeof cond !== 'object')
+            return null;
+        const c = { ...cond };
+        if (typeof c.ref === 'string') {
+            const known = ctx.lookupRef?.(c.ref);
+            if (!known)
+                return null;
+            delete c.ref;
+            c.selector_text = `${known.role}:${JSON.stringify(known.name)}`;
+        }
+        out.condition = c;
+    }
+    return entry;
+}
+/** 本步是否改变了界面:wait/wait_until 的"重截屏"只是观察,不算。 */
+export function outputIndicatesChange(action, output) {
+    if (action === 'wait' || action === 'wait_until')
+        return false;
+    return output.includes('Screen re-captured');
+}
+// ── 存储 ────────────────────────────────────────────────────────────────
+export function traceEnabled() {
+    const v = (process.env.MOCODE_FLOW_TRACE ?? '').trim().toLowerCase();
+    return v !== 'false' && v !== '0' && v !== 'off';
+}
+export function getTraceFilePath(sessionId = getCurrentSessionId()) {
+    if (!sessionId)
+        return null;
+    const root = getSandboxRoot() ?? process.cwd();
+    return path.join(root, '.mocode', 'sessions', sessionId, TRACE_FILENAME);
+}
+/** 读整个 trace;文件缺失/坏行一律跳过。 */
+export function readTrace(sessionId = getCurrentSessionId()) {
+    const file = getTraceFilePath(sessionId);
+    if (!file)
+        return [];
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        try {
+            const e = JSON.parse(s);
+            if (e && typeof e.seq === 'number' && typeof e.action === 'string' && e.args && typeof e.args === 'object') {
+                out.push(e);
+            }
+        }
+        catch {
+            /* 坏行跳过 */
+        }
+    }
+    return out;
+}
+/** 下一个序号 = 现有最大 seq + 1(无文件为 1)。 */
+export function nextTraceSeq(sessionId = getCurrentSessionId()) {
+    let max = 0;
+    for (const e of readTrace(sessionId))
+        if (e.seq > max)
+            max = e.seq;
+    return max + 1;
+}
+/** trace 单文件大小上限(字节):超过即裁剪到最近 TRACE_KEEP_ENTRIES 条。flow 导出只需要最近一段操作。 */
+export const TRACE_MAX_BYTES = 256 * 1024;
+export const TRACE_KEEP_ENTRIES = 200;
+/**
+ * 文件超过上限时只保留最近 `keep` 条(tmp+rename 原子写)。seq 不重编号——导出按 seq 取范围,
+ * nextTraceSeq 取现存最大值 +1,裁掉旧条目不影响后续序号单调递增。
+ * 会话整体归档/清除(session/retention.ts)时 trace 随会话目录一起删除:已固化的 flow 在 `.mocode/flows/`,不受影响。
+ */
+export function trimTraceFile(file, maxBytes = TRACE_MAX_BYTES, keep = TRACE_KEEP_ENTRIES) {
+    try {
+        if (fs.statSync(file).size <= maxBytes)
+            return false;
+        const lines = fs
+            .readFileSync(file, 'utf8')
+            .split('\n')
+            .filter((l) => l.trim());
+        if (lines.length <= keep)
+            return false;
+        const tmp = `${file}.tmp`;
+        fs.writeFileSync(tmp, `${lines.slice(-keep).join('\n')}\n`, 'utf8');
+        fs.renameSync(tmp, file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 追加一条;失败静默,返回是否写入成功。超过大小上限时顺带裁剪旧条目。 */
+export function appendTrace(entry, sessionId = getCurrentSessionId()) {
+    const file = getTraceFilePath(sessionId);
+    if (!file)
+        return false;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${JSON.stringify(entry)}\n`, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    trimTraceFile(file);
+    return true;
+}
+// ── 回放期间暂停录制 ─────────────────────────────────────────────────────
+let suspendDepth = 0;
+export function isTraceSuspended() {
+    return suspendDepth > 0;
+}
+/** 回放 flow 时包住执行:回放产生的动作不应再被当作"新录制"污染 trace。 */
+export async function withTraceSuspended(fn) {
+    suspendDepth += 1;
+    try {
+        return await fn();
+    }
+    finally {
+        suspendDepth -= 1;
+    }
+}
+/** flow 文件校验用:某动作在 trace/flow 里允许携带的 computer 参数名。 */
+export function recordedArgKeys(action) {
+    return KEEP_ARGS[action] ?? [];
+}

package/dist/i18n/index.js

@@ -34,6 +34,11 @@ const zhCN = {
     'commands.cuOn': '允许按需路由 computer-control',
     'commands.cuOff': '禁止 computer-control',
     'commands.cuStatus': '查看 Computer Use gate',
+    'commands.flow': '桌面流程：录制的 computer 动作导出/回放（flow）',
+    'commands.flowList': '列出已保存的 flow',
+    'commands.flowShow': '查看某个 flow 的步骤与参数',
+    'commands.flowSave': '把本会话录制的动作保存为 flow',
+    'commands.flowRun': '不经模型直接回放 flow',
     'commands.mcp': 'MCP 服务开关（重启后生效）',
     'commands.mcpOn': '开启 MCP 服务',
     'commands.mcpOff': '关闭 MCP 服务',
@@ -305,6 +310,15 @@ const zhCN = {
     'cu.usage': '用法：/cu on|off|status',
     'cu.visionWindow': '视觉窗口 · {frames} 条帧消息 · history 内 {images} 张图 · 约 {tokens} 图像 token · keep {keep}/batch {batch} · 已淘汰 {dropped}',
     'cu.actionLedger': '动作台账 · 已记录 {count} 条 GUI 动作',
+    'flow.usage': '用法：/flow list · /flow show <name> · /flow save <name> [--from N] [--to M] [--force] [描述] · /flow run <name> [--window <标题正则>] [参数=值 ...]',
+    'flow.noFlows': '还没有保存的 flow（.mocode/flows/）。先用 computer 操作一遍，再 /flow save <name>。',
+    'flow.saved': '已保存 flow "{name}"（{steps} 步）→ {path}',
+    'flow.savedParams': '回放时需提供参数：{params}（/flow run {name} 参数=值）',
+    'flow.fragile': '有 {count} 步是纯坐标动作，窗口位置变了就可能失效；建议改用 inspect + click_element 重新录制。',
+    'flow.gateOff': 'Computer Use 已被禁止（/cu off），无法回放 flow。先执行 /cu on。',
+    'flow.badParam': '参数格式应为 名称=值，收到：{token}',
+    'flow.cancelled': '(已取消回放)',
+    'flow.running': '正在回放 flow…',
     'mcp.status': 'MCP 服务：{state}',
     'mcp.stateOn': '开启',
     'mcp.stateOff': '关闭',
@@ -679,6 +693,20 @@ const en = {
     'cu.usage': 'Usage: /cu on|off|status',
     'cu.visionWindow': 'vision window · {frames} frame msg(s) · {images} image(s) in history · ~{tokens} image tk · keep {keep}/batch {batch} · {dropped} dropped',
     'cu.actionLedger': 'action ledger · {count} gui actions logged',
+    'flow.usage': 'Usage: /flow list · /flow show <name> · /flow save <name> [--from N] [--to M] [--force] [description] · /flow run <name> [--window <title-regex>] [param=value ...]',
+    'flow.noFlows': 'No saved flows yet (.mocode/flows/). Drive the desktop with computer first, then /flow save <name>.',
+    'flow.saved': 'Saved flow "{name}" ({steps} steps) → {path}',
+    'flow.savedParams': 'Parameters required at replay: {params} (/flow run {name} param=value)',
+    'flow.fragile': '{count} step(s) are pure-coordinate actions and may break if the window moves; consider re-recording with inspect + click_element.',
+    'flow.gateOff': 'Computer Use is blocked (/cu off), so flows cannot be replayed. Run /cu on first.',
+    'flow.badParam': 'Parameters must look like name=value, got: {token}',
+    'flow.cancelled': '(replay cancelled)',
+    'flow.running': 'Replaying flow…',
+    'commands.flow': 'Record and replay desktop flows',
+    'commands.flowList': 'List saved flows',
+    'commands.flowShow': "Show a flow's steps",
+    'commands.flowSave': "Save this session's computer actions as a flow",
+    'commands.flowRun': 'Replay a flow without the model',
     'mcp.status': 'MCP services: {state}',
     'mcp.stateOn': 'enabled',
     'mcp.stateOff': 'disabled',

package/dist/index.js

@@ -124,6 +124,13 @@ async function main() {
         await runConfigWizard();
         process.exit(0);
     }
+    // 桌面流程:mocode flow list | show <name> | run <name> ...(不经模型、不进 REPL;design-notes/computer-use-rpa.md §5.4)。
+    if (args[0] === 'flow') {
+        const { runFlowCli } = await import('./flows/cli.js');
+        const code = await runFlowCli(args.slice(1));
+        await shutdownRuntime();
+        process.exit(code);
+    }
     // Job runner 内部模式：detached 子进程入口。
     const runnerIdx = args.indexOf('--job-runner');
     if (runnerIdx !== -1) {

package/dist/llm/index.js

@@ -173,7 +173,7 @@ const STREAM_BREAK_CODES = new Set([
     'ETIMEDOUT',
     'ERR_SOCKET_CONNECTION_TIMEOUT',
 ]);
-const STREAM_BREAK_MESSAGE = /premature close|other side closed|socket hang up|\bterminated\b|stream (?:closed|ended) (?:prematurely|unexpectedly)|econnreset|econnaborted/i;
+const STREAM_BREAK_MESSAGE = /premature close|other side closed|socket hang up|\bterminated\b|stream (?:closed|ended) (?:prematurely|unexpectedly)|\bunexpected eof\b|econnreset|econnaborted/i;
 /**
  * 「连接层」可重试 errno。与 STREAM_BREAK_CODES 的区别:这些在**建连/发请求**阶段就失败
  * (DNS 解析、拒绝连接、路由不可达、连接超时),压根没有响应流可言,但处置一样 —— 重试。

package/dist/permissions/computer-review.js

@@ -0,0 +1,40 @@
+/**
+ * computer 敏感内容审查的纯谓词(叶子模块,无任何运行时依赖)。
+ *
+ * 从 permissions/index.ts 拆出:flows/(trace、flow)要在录制/导出/回放前复用同一套判定,
+ * 而 permissions/index.ts 反过来要读 flow 文件算 run_flow 的审查原因——谓词放叶子文件避免 import 环。
+ * permissions/index.ts 会原样 re-export,既有调用方与测试不受影响。
+ */
+/**
+ * computer 工具的 type/key 文本内容审查:
+ * 命中 URL / 密码形态 / 支付关键词时,无论是否已授权都强制 once 级确认——
+ * 这类文本是「把内容敲进任意应用」的载体,不能因 session/项目授权而放行后续所有输入。
+ * 纯函数,独立可单测。
+ */
+export function computerTextNeedsReview(text) {
+    const s = text.toLowerCase();
+    if (/https?:\/\/|www\.[a-z0-9-]+\.[a-z]{2,}/i.test(s))
+        return true;
+    if (/\b(pass(word)?|passwd|pwd|secret|token|api[_-]?key|credential)\b\s*[:=]/i.test(s))
+        return true;
+    if (/\b(card\s*number|cvv|cvc|expiry)\b/i.test(s))
+        return true;
+    // CJK 关键词没有 \b 词边界概念(\b 只在 \w 与非 \w 之间成立,中文不是 \w),用普通子串匹配。
+    if (/信用卡|卡号|密码|支付|付款|验证码/.test(s))
+        return true;
+    return false;
+}
+/**
+ * computer click_element 目标元素名审查(design-notes/computer-use-rpa.md §2.6):
+ * 名称命中删除/发送/提交/支付类关键词时强制 once 级确认——这类按钮一点即产生外部副作用,
+ * 不能因为「本会话允许 click_element」而静默放行。纯函数,独立可单测。
+ */
+export function computerTargetNeedsReview(name) {
+    const s = name.toLowerCase();
+    if (/\b(delete|remove|send|submit|pay|purchase|buy|checkout|confirm|transfer|uninstall|format|erase)\b/i.test(s)) {
+        return true;
+    }
+    if (/删除|移除|发送|提交|支付|付款|购买|下单|确认|转账|卸载|格式化|清空/.test(s))
+        return true;
+    return false;
+}

package/dist/permissions/flow-review.js

@@ -0,0 +1,41 @@
+/**
+ * run_flow 的权限审查输入:把"这次回放到底会做什么"在启动前一次算清(design-notes/computer-use-rpa.md §5.3)。
+ *
+ * 回放内部的单步不再走 checkPermission,所以整条 flow 的敏感判定必须在这里完成:
+ *   - 指纹绑定 flow 文件 hash:flow 被改过(哪怕同名)旧授权立即失效;
+ *   - reasons 非空 → 调用方强制 once 级确认(secret 参数、敏感文本、删除/发送/支付类目标)。
+ */
+import { flowReviewReasons, loadFlow, resolveParams, summarizeFlow } from '../flows/flow.js';
+const clip = (s, max) => (s.length > max ? `${s.slice(0, max)}…` : s);
+export function reviewFlowRun(args) {
+    const name = typeof args.name === 'string' ? args.name.trim() : '';
+    const loaded = loadFlow(name);
+    if (!loaded.ok) {
+        return { name, reasons: [], summary: `run_flow ${JSON.stringify(name)}: ${loaded.error}` };
+    }
+    const { flow } = loaded;
+    const given = args.params && typeof args.params === 'object' && !Array.isArray(args.params)
+        ? args.params
+        : undefined;
+    const resolved = resolveParams(flow, given);
+    // 参数不合法时回放会直接 rejected;审查按 default 兜底,保证仍能判定 secret / 敏感目标。
+    const values = resolved.ok
+        ? resolved.values
+        : Object.fromEntries(Object.entries(flow.params).flatMap(([k, p]) => (p.default !== undefined ? [[k, p.default]] : [])));
+    const reasons = flowReviewReasons(flow, values);
+    const paramLines = Object.entries(flow.params).map(([k, p]) => {
+        if (p.secret)
+            return `  ${k} = ***`;
+        const v = values[k];
+        return `  ${k} = ${v === undefined ? '(missing)' : JSON.stringify(clip(v, 60))}`;
+    });
+    const windowOverride = typeof args.window_title_regex === 'string' && args.window_title_regex.trim() !== ''
+        ? [`Window override: title matches /${clip(args.window_title_regex, 80)}/i for every window/element step`]
+        : [];
+    const summary = [
+        summarizeFlow(flow),
+        ...windowOverride,
+        ...(paramLines.length ? ['Parameter values:', ...paramLines] : []),
+    ].join('\n');
+    return { name, hash: loaded.hash, reasons, summary };
+}