minimal-agent 0.11.0 → 0.13.0

package/plugins/workflow-runner/src/types.js

@@ -12,6 +12,7 @@
  *  src/types.ts 的 LoopEvent union **不**包含 workflow_*，框架零插件耦合。
  * ============================================================
  */
+import { resolve, sep } from 'node:path';
 // ---------------- 2. 变量栈（loop scope 用） ----------------
 /**
  * 简单的多帧变量栈：
@@ -20,9 +21,21 @@
  *   - 退出 loop 时 pop()
  *
  * get(key) 从栈顶往下找第一个匹配的 frame，类似 JS 的 lexical scope。
+ *
+ * ════════════════ 原型污染防护（v2） ════════════════
+ *  三层防线，任何一层破了都还有下一层兜底：
+ *  ① 所有 frame 对象用 `Object.create(null)` 创建 → 根本没有原型访问器，
+ *     obj["__proto__"] = {...} 不会触发 setter（因为 Object.create(null)
+ *     的 [[Prototype]] 是 null，没有 Object.prototype.__proto__ 那个 getter/
+ *     setter），只会写成 own property。
+ *  ② set* 写入口统一过滤 DANGEROUS_KEYS（`__proto__/constructor/prototype`）
+ *     → 即使将来有人改回普通 {} 对象，写操作也到不了原型。
+ *  ③ 读侧（expressions 点路径访问）另有 S1 黑名防护（parsePrimary L451），
+ *     即使值真写进去了也读不出来。
+ * ════════════════════════════════════════════════════
  */
 export class VarStack {
-    frames = [{}];
+    frames = [Object.create(null)];
     /**
      * 哪些帧是「循环迭代帧」—— 只为装 `as` / `as_idx` 这类**每轮重置**的迭代变量而生。
      *
@@ -37,12 +50,24 @@ export class VarStack {
      * 而不是「它只在这一轮迭代里活着」。
      */
     iterationFrames = new Set();
+    /**
+     * 本次运行「当前有效工作目录」的解析器，供 fileExists / readJson 这类**读磁盘**的
+     * 内置函数取锚点用。不是 yaml 变量（不进 frames，`${cwd}` 取不到它）。
+     *
+     * ⚠️ 存的是**函数**不是字符串：worktree 是运行途中才进入的（模型调 EnterWorktree），
+     * 创建 VarStack 时固定成字符串的话，之后所有 done_when 仍会锚在旧目录上。
+     * 未设置时由调用方回落 getWorkingDir()。
+     */
+    resolveCwd;
     /**
      * 写一个**作者命名**的变量（capture / set 步 / 引擎内部状态）。
      *
      * 穿透所有迭代帧，落到最近的非迭代帧上 —— 这样它在循环结束后依然存在。
+     * 危险键（__proto__/constructor/prototype）直接忽略（防线②）。
      */
     set(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (!this.iterationFrames.has(i)) {
                 this.frames[i][key] = val;
@@ -51,15 +76,24 @@ export class VarStack {
         }
         this.frames[0][key] = val;
     }
-    /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。 */
+    /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。
+     *  危险键直接忽略（防线②）。 */
     setIteration(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         this.frames[this.frames.length - 1][key] = val;
     }
-    /** 写到栈底（root frame），用于 inputs / 全局常量 */
+    /** 写到栈底（root frame），用于 inputs / 全局常量。危险键直接忽略（防线②）。 */
     setGlobal(key, val) {
+        if (DANGEROUS_KEYS.has(key))
+            return;
         this.frames[0][key] = val;
     }
     get(key) {
+        // 读侧也过危险键：防止 Object.create(null) 上若后续被别的代码写入了 own property
+        // 形式的 __proto__，读出来再被其他地方当对象 key 造成二次污染。
+        if (DANGEROUS_KEYS.has(key))
+            return undefined;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (key in this.frames[i])
                 return this.frames[i][key];
@@ -67,6 +101,8 @@ export class VarStack {
         return undefined;
     }
     has(key) {
+        if (DANGEROUS_KEYS.has(key))
+            return false;
         for (let i = this.frames.length - 1; i >= 0; i--) {
             if (key in this.frames[i])
                 return true;
@@ -74,11 +110,11 @@ export class VarStack {
         return false;
     }
     push() {
-        this.frames.push({});
+        this.frames.push(Object.create(null));
     }
     /** 压一个迭代帧：只有 `setIteration` 写进来的东西会随 `pop` 消失。 */
     pushIteration() {
-        this.frames.push({});
+        this.frames.push(Object.create(null));
         this.iterationFrames.add(this.frames.length - 1);
     }
     pop() {
@@ -87,9 +123,18 @@ export class VarStack {
             this.frames.pop();
         }
     }
-    /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
+    /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件。
+     *  危险键不进入快照（双重保险：帧是 Object.create(null)，读的时候也过不了 get）。*/
     snapshot() {
-        return Object.assign({}, ...this.frames);
+        const out = {};
+        for (const frame of this.frames) {
+            for (const k of Object.keys(frame)) {
+                if (DANGEROUS_KEYS.has(k))
+                    continue;
+                out[k] = frame[k];
+            }
+        }
+        return out;
     }
 }
 /**
@@ -109,3 +154,64 @@ export function normalizeCapture(cap) {
         return { result: cap };
     return cap;
 }
+// ---------------- 6. 路径安全守卫（declaredArtifacts / 表达式层共用） ----------------
+/**
+ * 规范化 + cwd 范围校验的产物路径。
+ *
+ * 安全背景：declaredArtifacts 来自 YAML 定义，若作者写 "../../.ssh/id_rsa"，
+ * path.join(workingDir, p) 会跟随 ../ 跳出工作目录，new-task 清理时就可能
+ * 删掉工作目录外的文件（唯一能造成真实数据损失的入口）。
+ *
+ * 行为：
+ *   - 先用 resolve(workingDir, rawPath) 得到绝对路径（自动归一化 ../）
+ *   - 再检查它是否严格在 resolve(workingDir) 目录树之内
+ *   - 命中：返回【相对 workingDir 的规范化相对路径】（./ 前缀去除、\\→/），
+ *     保证后续 join(workingDir, result) 一定不会越界
+ *   - 越界/空串/解析失败：返回 null，调用方应跳过（fail-closed）
+ *
+ * 跨平台：win32 上 compare 前双方都 normalizeCase（lowercase），其他平台保持大小写敏感。
+ */
+export function safeArtifactPath(workingDir, rawPath) {
+    if (!rawPath || typeof rawPath !== 'string')
+        return null;
+    const base = resolve(workingDir);
+    // 必须加路径分隔符作为前缀匹配边界：防止 base=/repo 匹配到 /repo-hack/evil
+    const baseWithSep = base.endsWith(sep) ? base : base + sep;
+    let abs;
+    try {
+        abs = resolve(workingDir, rawPath);
+    }
+    catch {
+        return null;
+    }
+    const sameCase = (p) => process.platform === 'win32' ? p.toLowerCase() : p;
+    const nAbs = sameCase(abs);
+    const nBase = sameCase(base);
+    const nBaseSep = sameCase(baseWithSep);
+    // 恰好等于 base 本身（极端的 rawPath='.' 情形）也视为合法，但 caller 一般
+    // 用的是具体文件；这里允许不报错。
+    if (nAbs !== nBase && !nAbs.startsWith(nBaseSep))
+        return null;
+    // 导出【相对 workingDir 的相对路径】（去掉 base 前缀）
+    const rel = abs.slice(base.length).replace(/^[/\\]/, '');
+    return rel.length === 0 ? '.' : rel;
+}
+/**
+ * 表达式/任意场景的通用「绝对路径是否在 cwd 内」判定。
+ *   - abs 必须是【已 resolve 后的绝对路径】
+ *   - 越界/空 → false
+ */
+export function isAbsWithinCwd(workingDir, abs) {
+    if (!abs)
+        return false;
+    const base = resolve(workingDir);
+    const baseWithSep = base.endsWith(sep) ? base : base + sep;
+    const sameCase = (p) => process.platform === 'win32' ? p.toLowerCase() : p;
+    const nAbs = sameCase(abs);
+    return nAbs === sameCase(base) || nAbs.startsWith(sameCase(baseWithSep));
+}
+/**
+ * 危险键黑名单：VarStack.set* / interpolateDeep 对象 key / 点路径访问统一过滤。
+ * 防止原型污染 / 构造函数逃逸。与 expressions.ts parsePrimary S1 白名单保持一致。
+ */
+export const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);

package/plugins/workflow-runner/src/types.ts

@@ -13,12 +13,16 @@
  * ============================================================
  */
 
+import { resolve, sep } from 'node:path';
+
 import type {
   ImageDetail,
   Message,
+  PluginContext,
   Provider,
   SessionState,
   Tool,
+  ToolCallContext,
 } from '../../../src/plugin-sdk.js';
 
 // ---------------- 1. Workflow / Step 定义 ----------------
@@ -237,7 +241,7 @@ export interface StepDef {
   /** ADR-05: 仅 llm 节点声明的上下文文件清单（skill 节点 loader 拒绝）；runner 拼 path+hint 进 prompt 并开放 Read 子循环，不 inline 内容。 */
   context_files?: Array<{ path: string; hint?: string }>;
 
-  /** ADR-05: agent 节点的工具白名单；未声明时默认全量 ALL_TOOLS。 */
+  /** ADR-05: agent 节点的工具白名单；未声明时继承宿主过滤后的有效工具集。 */
   allowed_tools?: string[];
 
   /**
@@ -318,9 +322,21 @@ export interface WorkflowDef {
  *   - 退出 loop 时 pop()
  *
  * get(key) 从栈顶往下找第一个匹配的 frame，类似 JS 的 lexical scope。
+ *
+ * ════════════════ 原型污染防护（v2） ════════════════
+ *  三层防线，任何一层破了都还有下一层兜底：
+ *  ① 所有 frame 对象用 `Object.create(null)` 创建 → 根本没有原型访问器，
+ *     obj["__proto__"] = {...} 不会触发 setter（因为 Object.create(null)
+ *     的 [[Prototype]] 是 null，没有 Object.prototype.__proto__ 那个 getter/
+ *     setter），只会写成 own property。
+ *  ② set* 写入口统一过滤 DANGEROUS_KEYS（`__proto__/constructor/prototype`）
+ *     → 即使将来有人改回普通 {} 对象，写操作也到不了原型。
+ *  ③ 读侧（expressions 点路径访问）另有 S1 黑名防护（parsePrimary L451），
+ *     即使值真写进去了也读不出来。
+ * ════════════════════════════════════════════════════
  */
 export class VarStack {
-  private frames: Record<string, unknown>[] = [{}];
+  private frames: Record<string, unknown>[] = [Object.create(null)];
   /**
    * 哪些帧是「循环迭代帧」—— 只为装 `as` / `as_idx` 这类**每轮重置**的迭代变量而生。
    *
@@ -336,12 +352,24 @@ export class VarStack {
    */
   private iterationFrames = new Set<number>();
 
+  /**
+   * 本次运行「当前有效工作目录」的解析器，供 fileExists / readJson 这类**读磁盘**的
+   * 内置函数取锚点用。不是 yaml 变量（不进 frames，`${cwd}` 取不到它）。
+   *
+   * ⚠️ 存的是**函数**不是字符串：worktree 是运行途中才进入的（模型调 EnterWorktree），
+   * 创建 VarStack 时固定成字符串的话，之后所有 done_when 仍会锚在旧目录上。
+   * 未设置时由调用方回落 getWorkingDir()。
+   */
+  resolveCwd?: () => string;
+
   /**
    * 写一个**作者命名**的变量（capture / set 步 / 引擎内部状态）。
    *
    * 穿透所有迭代帧，落到最近的非迭代帧上 —— 这样它在循环结束后依然存在。
+   * 危险键（__proto__/constructor/prototype）直接忽略（防线②）。
    */
   set(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (!this.iterationFrames.has(i)) {
         this.frames[i][key] = val;
@@ -351,17 +379,23 @@ export class VarStack {
     this.frames[0][key] = val;
   }
 
-  /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。 */
+  /** 写一个**迭代变量**（`as` / `as_idx`）：落在当前迭代帧，随 pop 一起消失。
+   *  危险键直接忽略（防线②）。 */
   setIteration(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     this.frames[this.frames.length - 1][key] = val;
   }
 
-  /** 写到栈底（root frame），用于 inputs / 全局常量 */
+  /** 写到栈底（root frame），用于 inputs / 全局常量。危险键直接忽略（防线②）。 */
   setGlobal(key: string, val: unknown): void {
+    if (DANGEROUS_KEYS.has(key)) return;
     this.frames[0][key] = val;
   }
 
   get(key: string): unknown {
+    // 读侧也过危险键：防止 Object.create(null) 上若后续被别的代码写入了 own property
+    // 形式的 __proto__，读出来再被其他地方当对象 key 造成二次污染。
+    if (DANGEROUS_KEYS.has(key)) return undefined;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (key in this.frames[i]) return this.frames[i][key];
     }
@@ -369,6 +403,7 @@ export class VarStack {
   }
 
   has(key: string): boolean {
+    if (DANGEROUS_KEYS.has(key)) return false;
     for (let i = this.frames.length - 1; i >= 0; i--) {
       if (key in this.frames[i]) return true;
     }
@@ -376,12 +411,12 @@ export class VarStack {
   }
 
   push(): void {
-    this.frames.push({});
+    this.frames.push(Object.create(null));
   }
 
   /** 压一个迭代帧：只有 `setIteration` 写进来的东西会随 `pop` 消失。 */
   pushIteration(): void {
-    this.frames.push({});
+    this.frames.push(Object.create(null));
     this.iterationFrames.add(this.frames.length - 1);
   }
 
@@ -392,9 +427,17 @@ export class VarStack {
     }
   }
 
-  /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件 */
+  /** 合并所有帧为一个普通对象（外层覆盖内层），用于 vars 持久化与事件。
+   *  危险键不进入快照（双重保险：帧是 Object.create(null)，读的时候也过不了 get）。*/
   snapshot(): Record<string, unknown> {
-    return Object.assign({}, ...this.frames);
+    const out: Record<string, unknown> = {};
+    for (const frame of this.frames) {
+      for (const k of Object.keys(frame)) {
+        if (DANGEROUS_KEYS.has(k)) continue;
+        out[k] = frame[k];
+      }
+    }
+    return out;
   }
 }
 
@@ -437,10 +480,9 @@ export interface RunContext {
   cwd: string;
   /**
    * 可用工具列表。
-   * v0.9 重构后：agent/llm/skill 步委托 runQuery(TAOR) 执行，
-   * runQuery 内部使用自己的 ALL_TOOLS 全量工具列表。
-   * 此字段保留给 runner 内部确定性步（tool 步）的 executeTool 调度使用，
-   * 以及测试兼容。生产路径由 plugin.ts 注入 ALL_TOOLS。
+   * agent/llm/skill 与确定性 tool 步都以此列表为宿主授权上限。
+   * plugin.ts 先按 runtime 和父宿主白名单过滤，再把同一列表交给提示词、
+   * Schema 和真实执行，任何工作流节点都不能从 ALL_TOOLS 恢复隐藏能力。
    */
   tools: Tool[];
   transientContext?: string;
@@ -494,11 +536,29 @@ export interface RunContext {
     tools: import('../../../src/plugin-sdk.js').Tool[];
     signal?: AbortSignal;
     promptCache?: import('../../../src/plugin-sdk.js').PromptCacheContext;
-  }) => AsyncGenerator<import('../../../src/plugin-sdk.js').LlmStreamEvent, void, undefined>;
+  }) => AsyncGenerator<
+    import('../../../src/plugin-sdk.js').LlmStreamEvent,
+    void,
+    undefined
+  >;
   /**
    * DI：executeTool 实现（仅测试用）。同上。
    */
-  executeTool?: (name: string, rawArgsJson: string, signal?: AbortSignal) => Promise<import('../../../src/plugin-sdk.js').ToolResult>;
+  executeTool?: PluginContext['executeTool'];
+  /**
+   * Canonical non-model-visible context shared by deterministic tool nodes.
+   * Browser/computer capabilities are deliberately excluded here and are only
+   * added by the step-level `uses` slicer.
+   */
+  toolContext?: Omit<
+    ToolCallContext,
+    | 'browserRun'
+    | 'computerRun'
+    | 'computerIntervention'
+    | 'reportProgress'
+    | 'toolCallId'
+    | 'cwd'
+  >;
   /**
    * 会话状态（驱动 microCompact / reactiveCompact）。
    *
@@ -581,3 +641,66 @@ export type WorkflowEvent =
     }
   | { type: 'workflow_step_skipped'; id: string; reason: string }
   | { type: 'workflow_done'; name: string; vars: Record<string, unknown> };
+
+// ---------------- 6. 路径安全守卫（declaredArtifacts / 表达式层共用） ----------------
+
+/**
+ * 规范化 + cwd 范围校验的产物路径。
+ *
+ * 安全背景：declaredArtifacts 来自 YAML 定义，若作者写 "../../.ssh/id_rsa"，
+ * path.join(workingDir, p) 会跟随 ../ 跳出工作目录，new-task 清理时就可能
+ * 删掉工作目录外的文件（唯一能造成真实数据损失的入口）。
+ *
+ * 行为：
+ *   - 先用 resolve(workingDir, rawPath) 得到绝对路径（自动归一化 ../）
+ *   - 再检查它是否严格在 resolve(workingDir) 目录树之内
+ *   - 命中：返回【相对 workingDir 的规范化相对路径】（./ 前缀去除、\\→/），
+ *     保证后续 join(workingDir, result) 一定不会越界
+ *   - 越界/空串/解析失败：返回 null，调用方应跳过（fail-closed）
+ *
+ * 跨平台：win32 上 compare 前双方都 normalizeCase（lowercase），其他平台保持大小写敏感。
+ */
+export function safeArtifactPath(workingDir: string, rawPath: string): string | null {
+  if (!rawPath || typeof rawPath !== 'string') return null;
+  const base = resolve(workingDir);
+  // 必须加路径分隔符作为前缀匹配边界：防止 base=/repo 匹配到 /repo-hack/evil
+  const baseWithSep = base.endsWith(sep) ? base : base + sep;
+  let abs: string;
+  try {
+    abs = resolve(workingDir, rawPath);
+  } catch {
+    return null;
+  }
+  const sameCase = (p: string): string =>
+    process.platform === 'win32' ? p.toLowerCase() : p;
+  const nAbs = sameCase(abs);
+  const nBase = sameCase(base);
+  const nBaseSep = sameCase(baseWithSep);
+  // 恰好等于 base 本身（极端的 rawPath='.' 情形）也视为合法，但 caller 一般
+  // 用的是具体文件；这里允许不报错。
+  if (nAbs !== nBase && !nAbs.startsWith(nBaseSep)) return null;
+  // 导出【相对 workingDir 的相对路径】（去掉 base 前缀）
+  const rel = abs.slice(base.length).replace(/^[/\\]/, '');
+  return rel.length === 0 ? '.' : rel;
+}
+
+/**
+ * 表达式/任意场景的通用「绝对路径是否在 cwd 内」判定。
+ *   - abs 必须是【已 resolve 后的绝对路径】
+ *   - 越界/空 → false
+ */
+export function isAbsWithinCwd(workingDir: string, abs: string): boolean {
+  if (!abs) return false;
+  const base = resolve(workingDir);
+  const baseWithSep = base.endsWith(sep) ? base : base + sep;
+  const sameCase = (p: string): string =>
+    process.platform === 'win32' ? p.toLowerCase() : p;
+  const nAbs = sameCase(abs);
+  return nAbs === sameCase(base) || nAbs.startsWith(sameCase(baseWithSep));
+}
+
+/**
+ * 危险键黑名单：VarStack.set* / interpolateDeep 对象 key / 点路径访问统一过滤。
+ * 防止原型污染 / 构造函数逃逸。与 expressions.ts parsePrimary S1 白名单保持一致。
+ */
+export const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);