u1s1-cli 0.16.6 → 0.18.0

package/dist/workflow/runner.js

@@ -0,0 +1,333 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import vm from "node:vm";
+import { dirname, resolve } from "node:path";
+import { runPool, runSubagent, SUBAGENT_CONCURRENCY } from "../subagent.js";
+// ---- WorkflowRunner:执行模型生成的编排脚本(路线 A:主进程 vm 上下文) ----
+// 定位「防误不防恶」:vm 非硬安全边界,靠白名单注入 + 静态校验 + 脚本落盘可审查兜底。
+/** 整个 run 的默认墙钟上限。 */
+export const WORKFLOW_TIMEOUT_MS = 30 * 60_000;
+/** 单个子任务的超时(与 spawn_subagent 工具一致)。 */
+const PER_TASK_TIMEOUT_MS = 15 * 60_000;
+/** 报告里最多保留多少行脚本 log 输出。 */
+const MAX_LOG_LINES = 60;
+/** 默认整个 run 的 token 预算;0 或负数表示不设限。 */
+export const WORKFLOW_DEFAULT_BUDGET_TOKENS = 20_000_000;
+/** JSONL 进度存档:一行一个已完成的子任务,断点续跑时按 key 跳过。 */
+class ProgressStore {
+    path;
+    #cache = new Map();
+    constructor(path) {
+        this.path = path;
+        mkdirSync(dirname(path), { recursive: true });
+        if (!existsSync(path))
+            return;
+        for (const line of readFileSync(path, "utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (typeof e.key === "string")
+                    this.#cache.set(e.key, e);
+            }
+            catch {
+                // 尾部半行(进程被杀)直接忽略
+            }
+        }
+    }
+    get(key) {
+        return this.#cache.get(key);
+    }
+    append(entry) {
+        this.#cache.set(entry.key, entry);
+        appendFileSync(this.path, `${JSON.stringify(entry)}\n`);
+    }
+}
+/**
+ * 断点续跑的任务标识:任务内容 + 模型的哈希。
+ * 前提是脚本确定性好 —— 相同任务串在续跑时视为同一任务(循环里重复相同任务串
+ * 的场景续跑粒度不精确,W1 接受此限制;i18n 这类每项任务内容唯一的场景完全够用)。
+ */
+function taskKey(task, model) {
+    return createHash("sha1").update(`${task}|${model ?? ""}`).digest("hex").slice(0, 16);
+}
+/** 去掉注释和字符串字面量后再扫禁用模式,避免文档式注释误报。 */
+function stripCommentsAndStrings(code) {
+    return code
+        .replace(/\/\*[\s\S]*?\*\//g, " ")
+        .replace(/(^|[^:])\/\/[^\n]*/g, "$1 ")
+        .replace(/"(?:[^"\\\n]|\\.)*"/g, '""')
+        .replace(/'(?:[^'\\\n]|\\.)*'/g, "''")
+        .replace(/`(?:[^`\\]|\\.)*`/g, "``");
+}
+/** 静态白名单校验:语法能编译 + 不碰沙箱之外的任何能力。 */
+export function validateScript(code) {
+    const errors = [];
+    try {
+        // 与执行时同款包装,保证报错行号一致
+        new vm.Script(`(async () => {\n${code}\n})()`, { filename: "workflow.mjs" });
+    }
+    catch (e) {
+        errors.push(`语法错误:${e.message}`);
+        return errors;
+    }
+    const bare = stripCommentsAndStrings(code);
+    const forbidden = [
+        [/\brequire\s*\(/, "require()"],
+        [/\bimport\s*\(/, "动态 import()"],
+        [/^\s*import\s/m, "静态 import"],
+        [/\bprocess\b/, "process 对象"],
+        [/\bglobalThis\b/, "globalThis"],
+        [/\bfetch\s*\(/, "fetch()"],
+        [/\beval\s*\(/, "eval()"],
+        [/\bFunction\s*\(/, "new Function()"],
+        [/\.constructor\b/, ".constructor(原型链逃逸)"],
+        [/\bprototype\b/, "prototype(原型链逃逸)"],
+        [/\b__proto__\b/, "__proto__"],
+        [/\bWebAssembly\b/, "WebAssembly"],
+        [/node:/, "node: 内置模块"],
+        [/child_process/, "child_process"],
+        [/\bfs\b\s*\./, "fs 模块"],
+    ];
+    for (const [re, label] of forbidden) {
+        if (re.test(bare))
+            errors.push(`脚本使用了沙箱之外的能力:${label}`);
+    }
+    return errors;
+}
+/** 执行一个 workflow 脚本,返回给主对话的报告。不抛错——失败也进报告让模型自行修复。 */
+export async function runWorkflow(opts) {
+    const started = Date.now();
+    const logs = [];
+    const stats = { spawns: 0, ok: 0, failed: 0, cached: 0 };
+    // 内部中止控制器:父会话 ESC 或整体超时都会触发,并传导到每个子 session
+    const internal = new AbortController();
+    const onParentAbort = () => internal.abort(opts.signal?.reason);
+    opts.signal?.addEventListener("abort", onParentAbort, { once: true });
+    let timedOut = false;
+    const overallTimer = setTimeout(() => {
+        timedOut = true;
+        internal.abort(new Error(`整个工作流超时(${Math.round((opts.timeoutMs ?? WORKFLOW_TIMEOUT_MS) / 60_000)} 分钟)`));
+    }, opts.timeoutMs ?? WORKFLOW_TIMEOUT_MS);
+    const store = new ProgressStore(opts.progressPath);
+    const budgetTokens = opts.budgetTokens ?? WORKFLOW_DEFAULT_BUDGET_TOKENS;
+    let spentTokens = 0;
+    let running = 0;
+    const progress = { spawns: 0, ok: 0, failed: 0, cached: 0, running: 0, spentTokens: 0, budgetTokens };
+    const reportProgress = () => {
+        progress.spentTokens = spentTokens;
+        opts.onProgress?.({ ...progress });
+    };
+    /** git worktree 隔离:在 .u1s1/worktrees/ 下建临时工作树,返回其路径。 */
+    let worktreeSeq = 0;
+    function createTempWorktree() {
+        const dir = resolve(workflowsDir(), "../../.u1s1-worktrees", `wf-${Date.now()}-${++worktreeSeq}`);
+        execFileSync("git", ["worktree", "add", "--detach", dir], { stdio: "pipe" });
+        return dir;
+    }
+    function removeWorktree(dir) {
+        try {
+            execFileSync("git", ["worktree", "remove", "--force", dir], { stdio: "pipe" });
+        }
+        catch {
+            rmSync(dir, { recursive: true, force: true });
+            try {
+                execFileSync("git", ["worktree", "prune"], { stdio: "pipe" });
+            }
+            catch {
+                // 尽力清理即可
+            }
+        }
+    }
+    /** 注入沙箱的 subagent():字符串或 {task, model, worktree} 都行,返回最终输出文本。 */
+    async function subagentImpl(input) {
+        const o = typeof input === "string" ? { task: input } : (input ?? {});
+        const task = typeof o.task === "string" ? o.task.trim() : "";
+        if (!task)
+            throw new Error("subagent() 需要 task 字符串");
+        const model = typeof o.model === "string" && o.model ? o.model : undefined;
+        if (internal.signal.aborted)
+            throw new Error("工作流已中止,不再派发新子任务");
+        if (budgetTokens > 0 && spentTokens >= budgetTokens) {
+            throw new Error(`token 预算已用尽(已用 ${spentTokens.toLocaleString()} / 上限 ${budgetTokens.toLocaleString()}),不再派发新子任务`);
+        }
+        const key = taskKey(task, model);
+        if (opts.resume) {
+            const prev = store.get(key);
+            if (prev) {
+                stats.cached++;
+                progress.cached = stats.cached;
+                reportProgress();
+                if (prev.ok)
+                    return prev.text;
+                throw new Error(prev.text);
+            }
+        }
+        stats.spawns++;
+        progress.spawns = stats.spawns;
+        running++;
+        progress.running = running;
+        reportProgress();
+        const t0 = Date.now();
+        let worktreeDir;
+        if (o.worktree === true)
+            worktreeDir = createTempWorktree();
+        try {
+            const out = await runSubagent({
+                task,
+                model,
+                parentModel: opts.parentModel,
+                timeoutMs: PER_TASK_TIMEOUT_MS,
+                signal: internal.signal,
+                cwd: worktreeDir,
+                noTools: o.noTools === true,
+            });
+            stats.ok++;
+            progress.ok = stats.ok;
+            spentTokens += out.usage.totalTokens;
+            store.append({ key, task: task.slice(0, 120), ok: true, text: out.text, ms: Date.now() - t0 });
+            return out.text;
+        }
+        catch (e) {
+            stats.failed++;
+            progress.failed = stats.failed;
+            const msg = e.message || "未知错误";
+            store.append({ key, task: task.slice(0, 120), ok: false, text: msg, ms: Date.now() - t0 });
+            throw new Error(msg);
+        }
+        finally {
+            if (worktreeDir)
+                removeWorktree(worktreeDir);
+            running--;
+            progress.running = running;
+            reportProgress();
+        }
+    }
+    /** 注入沙箱的 judge():廉价无工具模型调用,严格回答 PASS/FAIL,转成布尔。 */
+    async function judgeImpl(question) {
+        if (typeof question !== "string" || !question.trim())
+            throw new Error("judge() 需要问题字符串");
+        const answer = await subagentImpl({
+            task: `回答以下判定问题。只允许回答一个词:PASS 或 FAIL,不要任何其他内容。\n\n判定问题:${question.trim()}`,
+            noTools: true,
+        });
+        const pass = /\bPASS\b/i.test(answer) && !/\bFAIL\b/i.test(answer);
+        if (!pass && !/\bFAIL\b/i.test(answer))
+            logs.push(`⚠ judge 回答无法解析,按 FAIL 处理:${answer.slice(0, 120)}`);
+        return pass;
+    }
+    /** barrier 扇出:全部并发(封顶排队),单个失败该项为 null,不拖垮整批。 */
+    async function parallel(thunks) {
+        if (!Array.isArray(thunks))
+            throw new Error("parallel() 需要一个 thunk 数组");
+        const results = new Array(thunks.length);
+        await runPool(thunks, SUBAGENT_CONCURRENCY, async (thunk, i) => {
+            results[i] = await Promise.resolve()
+                .then(thunk)
+                .catch((e) => {
+                logs.push(`✗ 任务 ${i + 1} 失败:${e.message}`);
+                return null;
+            });
+        }, internal.signal);
+        return results;
+    }
+    /** 无屏障流水线:每个 item 独立穿过所有 stage,item 失败只废自己。 */
+    async function pipeline(items, stages) {
+        if (!Array.isArray(items))
+            throw new Error("pipeline() 第一个参数需要数组");
+        if (!Array.isArray(stages) || stages.length === 0)
+            throw new Error("pipeline() 第二个参数需要非空 stage 数组");
+        const results = new Array(items.length);
+        await runPool(items, SUBAGENT_CONCURRENCY, async (item, i) => {
+            let current = item;
+            for (let s = 0; s < stages.length; s++) {
+                try {
+                    current = await stages[s](current);
+                }
+                catch (e) {
+                    logs.push(`✗ item ${i + 1} 在第 ${s + 1} 阶段失败:${e.message}`);
+                    current = null;
+                    break;
+                }
+            }
+            results[i] = current;
+        }, internal.signal);
+        return results;
+    }
+    // 沙箱:只有编排原语 + 受限 log/timer,标准 JS 内建(Promise/JSON/Math…)天然可用
+    const fmtLogArg = (a) => typeof a === "string" ? a : (() => { try {
+        return JSON.stringify(a);
+    }
+    catch {
+        return String(a);
+    } })();
+    const pushLog = (...args) => {
+        if (logs.length < 500)
+            logs.push(args.map(fmtLogArg).join(" "));
+    };
+    const sandbox = {
+        subagent: subagentImpl,
+        parallel,
+        pipeline,
+        judge: judgeImpl,
+        log: pushLog,
+        console: { log: pushLog, info: pushLog, warn: pushLog, error: pushLog },
+        setTimeout: (fn, ms) => setTimeout(fn, Math.max(0, Math.min(Number(ms) || 0, 120_000))),
+        clearTimeout,
+    };
+    let scriptError;
+    let completionValue;
+    try {
+        // 包成 async IIFE:支持顶层 await 和 return;line 数与校验时一致
+        const script = new vm.Script(`(async () => {\n${opts.code}\n})()`, { filename: "workflow.mjs" });
+        const ctx = vm.createContext(sandbox);
+        completionValue = await Promise.resolve().then(() => script.runInContext(ctx));
+    }
+    catch (e) {
+        scriptError = e.stack?.split("\n").slice(0, 3).join("\n") || e.message;
+    }
+    finally {
+        clearTimeout(overallTimer);
+        opts.signal?.removeEventListener("abort", onParentAbort);
+    }
+    const seconds = Math.round((Date.now() - started) / 1000);
+    const aborted = internal.signal.aborted;
+    const budgetExhausted = budgetTokens > 0 && spentTokens >= budgetTokens;
+    const details = { ...stats, seconds, aborted, spentTokens, budgetExhausted };
+    const lines = [`工作流结束,用时 ${seconds}s · 子任务 ✓${stats.ok} ✗${stats.failed}${stats.cached ? ` · 续跑命中 ${stats.cached}` : ""} · 用 ${spentTokens.toLocaleString()} tokens${budgetTokens > 0 ? ` / 预算 ${budgetTokens.toLocaleString()}` : " (不限)"}${timedOut ? " · ⏱ 整体超时" : ""}${aborted && !timedOut ? " · 已中止" : ""}`, ""];
+    if (completionValue !== undefined) {
+        let shown;
+        try {
+            shown = JSON.stringify(completionValue, null, 2) ?? String(completionValue);
+        }
+        catch {
+            shown = String(completionValue);
+        }
+        lines.push("**返回值**", "", shown.slice(0, 3000), "");
+    }
+    if (scriptError)
+        lines.push("**脚本报错**", "", "```", scriptError, "```", "");
+    if (logs.length > 0) {
+        lines.push("**运行日志**", "", ...logs.slice(0, MAX_LOG_LINES).map((l) => `- ${l.slice(0, 300)}`));
+        if (logs.length > MAX_LOG_LINES)
+            lines.push(`- …(另有 ${logs.length - MAX_LOG_LINES} 条省略)`);
+        lines.push("");
+    }
+    lines.push(`进度存档:${opts.progressPath}(失败重跑可加 resume=true 续跑)`);
+    return { report: lines.join("\n").trim(), details };
+}
+/** 工作区目录:项目根 .u1s1/workflows/(脚本 + 进度存档都在这里)。 */
+export function workflowsDir() {
+    const dir = resolve(process.cwd(), ".u1s1/workflows");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/** 内联脚本落盘,返回脚本路径(进度存档按同名约定派生)。 */
+export function saveWorkflowScript(code) {
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/T(\d{6}).*/, "-$1");
+    const path = resolve(workflowsDir(), `wf-${stamp}.mjs`);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, code);
+    return path;
+}

package/dist/workflow/tool.d.ts

@@ -0,0 +1,13 @@
+import { Type } from "typebox";
+import type { ParentModelRef } from "../subagent.js";
+/**
+ * run_workflow 工具:主 agent 把模型生成的编排脚本交给 WorkflowRunner 执行。
+ * 脚本在 vm 沙箱里跑,只能用注入的 subagent/parallel/pipeline 原语。
+ */
+export declare function createRunWorkflowTool(getParentModel: () => ParentModelRef): import("@earendil-works/pi-coding-agent").ToolDefinition<Type.TObject<{
+    script: Type.TOptional<Type.TString>;
+    script_path: Type.TOptional<Type.TString>;
+    resume: Type.TOptional<Type.TBoolean>;
+    timeout_minutes: Type.TOptional<Type.TNumber>;
+    budget_tokens: Type.TOptional<Type.TNumber>;
+}>, unknown, any> & import("@earendil-works/pi-coding-agent").ToolDefinition<any, any, any>;

package/dist/workflow/tool.js

@@ -0,0 +1,119 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { compactResultRender, truncate } from "../tools.js";
+import { runWorkflow, saveWorkflowScript, validateScript, workflowsDir, WORKFLOW_DEFAULT_BUDGET_TOKENS, WORKFLOW_TIMEOUT_MS, } from "./runner.js";
+/**
+ * run_workflow 工具:主 agent 把模型生成的编排脚本交给 WorkflowRunner 执行。
+ * 脚本在 vm 沙箱里跑,只能用注入的 subagent/parallel/pipeline 原语。
+ */
+export function createRunWorkflowTool(getParentModel) {
+    return defineTool({
+        name: "run_workflow",
+        label: "工作流",
+        description: "Execute a JavaScript orchestration script that runs many sub-agents in structured patterns (fan-out/pipeline/loop). " +
+            "The script runs in a sandbox with ONLY these APIs: `subagent(task | {task, model})` returns the sub-agent's final output; " +
+            "`parallel([thunks])` fans out concurrently, a failed item becomes null (barrier); " +
+            "`pipeline(items, [stageFns])` streams each item through stages independently; plus `log(...)` and standard JS builtins. " +
+            "No require/import/process/fetch/fs access. Use for large parallelizable work (e.g. translate N locale files); " +
+            "don't use it for small tasks — write the script, pass it as `script`, then verify the report.",
+        promptSnippet: "Run a generated orchestration script that drives many sub-agents in parallel/pipeline patterns",
+        promptGuidelines: [
+            "Use run_workflow only when a task decomposes into many independent self-contained pieces; small jobs are cheaper done directly.",
+            "Every task string inside the script must be fully self-contained — sub-agents start with zero conversation context.",
+            "If the report shows failures, fix the script or call again with script_path + resume:true to continue from saved progress.",
+        ],
+        parameters: Type.Object({
+            script: Type.Optional(Type.String({ description: "Full JavaScript source of the orchestration script (top-level await allowed)." })),
+            script_path: Type.Optional(Type.String({
+                description: "Path to an existing workflow script under .u1s1/workflows/ — rerun it instead of passing `script`.",
+            })),
+            resume: Type.Optional(Type.Boolean({
+                description: "Skip sub-tasks already recorded as succeeded in the progress file (for crash/interrupt recovery).",
+            })),
+            timeout_minutes: Type.Optional(Type.Number({
+                description: `Wall-clock limit for the whole run in minutes (default ${WORKFLOW_TIMEOUT_MS / 60_000}, max 180).`,
+                minimum: 1,
+                maximum: 180,
+            })),
+            budget_tokens: Type.Optional(Type.Number({
+                description: `Total token ceiling for the whole run across all sub-agents (default ${WORKFLOW_DEFAULT_BUDGET_TOKENS}). Once exceeded, no new sub-agents are spawned; running ones finish. Use 0 for unlimited.`,
+                minimum: 0,
+                maximum: 1_000_000_000,
+            })),
+        }),
+        // 精简展示与 spawn_subagent 同款:收起一行摘要,ctrl+o 展开报告
+        renderShell: "self",
+        renderCall() {
+            return new Text("", 0, 0);
+        },
+        renderResult(result, options, theme, context) {
+            const d = result.details;
+            const summary = d && typeof d.ok === "number"
+                ? `🧭 工作流 · ✓${d.ok}${d.failed ? ` ✗${d.failed}` : ""}` +
+                    (typeof d.seconds === "number" ? ` · ${d.seconds}s` : "") +
+                    (d.aborted ? " · 已中止" : "")
+                : "🧭 工作流";
+            return compactResultRender(result, options, theme, context, summary);
+        },
+        async execute(_toolCallId, params, signal, onUpdate) {
+            let code = params.script?.trim();
+            let scriptPath;
+            if (code) {
+                const errors = validateScript(code);
+                if (errors.length > 0) {
+                    throw new Error(`脚本未通过静态校验,请修复后重试:\n- ${errors.join("\n- ")}`);
+                }
+                scriptPath = saveWorkflowScript(code);
+            }
+            else if (params.script_path?.trim()) {
+                scriptPath = resolve(params.script_path.trim());
+                try {
+                    code = readFileSync(scriptPath, "utf8");
+                }
+                catch {
+                    throw new Error(`读不到脚本文件:${scriptPath}`);
+                }
+            }
+            else {
+                throw new Error("script 和 script_path 至少填一个");
+            }
+            const progressPath = scriptPath.replace(/\.mjs$/, ".progress.jsonl");
+            // 流式进度:onProgress 高频触发,节流到 ≥2s 一次才推给 TUI
+            let lastPush = 0;
+            const onProgress = onUpdate
+                ? (p) => {
+                    const now = Date.now();
+                    if (now - lastPush < 2_000)
+                        return;
+                    lastPush = now;
+                    onUpdate({
+                        content: [
+                            {
+                                type: "text",
+                                text: `🧭 子任务 ✓${p.ok} ✗${p.failed}${p.cached ? ` 缓存${p.cached}` : ""} · 在跑 ${p.running} · ${(p.spentTokens / 1000).toFixed(0)}k${p.budgetTokens > 0 ? ` / ${(p.budgetTokens / 1000).toFixed(0)}k tokens` : ""}`,
+                            },
+                        ],
+                        details: p,
+                    });
+                }
+                : undefined;
+            const result = await runWorkflow({
+                code: code ?? "",
+                progressPath,
+                resume: params.resume === true,
+                parentModel: getParentModel(),
+                signal,
+                timeoutMs: Math.min(180, params.timeout_minutes ?? WORKFLOW_TIMEOUT_MS / 60_000) * 60_000,
+                budgetTokens: params.budget_tokens,
+                onProgress,
+            });
+            return {
+                content: [{ type: "text", text: truncate(result.report) }],
+                details: { ...result.details, scriptPath, workflowsDir: workflowsDir() },
+            };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u1s1-cli",
-  "version": "0.16.6",
+  "version": "0.18.0",
   "description": "u1s1 — 有一说一,最省心的 AI 编程搭子。终端里用中文说需求,AI 帮你读文件、改代码、跑命令。",
   "type": "module",
   "bin": {