@fieldwangai/agentflow 0.1.25

package/bin/pipeline/run-tool-nodejs.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * 运行 tool_nodejs 脚本并将结果写入流水线。
+ *
+ * 成败判定（Unix 哲学）：
+ *   - 进程 exit code 0 → success，非 0 → failed
+ *   - 若 stdout 为合法 JSON 且含 err_code，err_code 优先（向后兼容旧脚本）
+ *
+ * stdout 内容 → result 槽位：
+ *   - JSON 模式：提取 message.result
+ *   - 纯文本模式：整段 stdout 作为 result
+ *
+ * 用法：node run-tool-nodejs.mjs <workspaceRoot> <flowName> <uuid> <instanceId> [execId] -- <scriptCmd> [args...]
+ */
+
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { getRunDir } from "../lib/paths.mjs";
+import { validateAndParse } from "./validate-script-output.mjs";
+import { writeResult } from "./write-result.mjs";
+import { loadExecId, outputNodeBasename, outputDirForNode } from "./get-exec-id.mjs";
+import { nodeToolCommandToArgv } from "../lib/normalize-node-tool-command.mjs";
+import { buildPipelineScriptPathHint } from "../lib/flow-normalize.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000;
+
+function runOnce(workspaceRoot, flowName, uuid, instanceId, execId, scriptArgs) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const outputDir = path.join(runDir, outputDirForNode(instanceId));
+
+  const rawLine = scriptArgs.join(" ");
+  const { argv, commandLine: normalizedCmd } = nodeToolCommandToArgv(rawLine);
+  const child =
+    /^node\s/i.test(String(normalizedCmd).trim()) && argv.length >= 1
+      ? spawnSync(process.execPath, argv, {
+          cwd: workspaceRoot,
+          shell: false,
+          stdio: ["inherit", "pipe", "pipe"],
+        })
+      : spawnSync(normalizedCmd, [], {
+          cwd: workspaceRoot,
+          shell: true,
+          stdio: ["inherit", "pipe", "pipe"],
+        });
+
+  const stdout = child.stdout?.toString("utf-8") ?? "";
+  const stderr = child.stderr?.toString("utf-8") ?? "";
+  const exitCode = child.status ?? 1;
+
+  if (child.signal) {
+    persistStderr(outputDir, instanceId, execId, stderr);
+    return { success: false, fatal: true, detail: `Script killed: ${child.signal}` };
+  }
+
+  const { ok, errors, payload } = validateAndParse(stdout);
+
+  if (!ok) {
+    const baseDetail = exitCode !== 0
+      ? `脚本退出码 ${exitCode}` + (stderr.trim() ? `：${stderr.trim().slice(0, 200)}` : "")
+      : (errors.length ? errors.join("; ") : "脚本无输出");
+    const detail = baseDetail + buildPipelineScriptPathHint(stderr);
+    writeResult(workspaceRoot, flowName, uuid, instanceId, {
+      status: "failed",
+      message: detail,
+    }, { preserveBody: true, execId });
+    persistStderr(outputDir, instanceId, execId, stderr);
+    return { success: false, fatal: false, detail };
+  }
+
+  const isSynthetic = Boolean(payload._synthetic);
+  const success = isSynthetic ? exitCode === 0 : (payload.err_code === 0);
+  const message = payload.message;
+
+  try {
+    fs.mkdirSync(outputDir, { recursive: true });
+    // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理。
+    for (const slot of Object.keys(message)) {
+      if (slot === "_synthetic") continue;
+      const content = message[slot];
+      if (content == null) continue;
+      fs.writeFileSync(
+        path.join(outputDir, outputNodeBasename(instanceId, execId, slot)),
+        String(content),
+        "utf-8",
+      );
+    }
+    writeResult(workspaceRoot, flowName, uuid, instanceId, {
+      status: success ? "success" : "failed",
+      message: success ? "执行完成" : "执行未通过",
+    }, { preserveBody: true, execId });
+  } catch (e) {
+    writeResult(workspaceRoot, flowName, uuid, instanceId, {
+      status: "failed",
+      message: e.message || "写入 output/result 异常",
+    }, { preserveBody: true, execId });
+    persistStderr(outputDir, instanceId, execId, stderr);
+    return { success: false, fatal: false, detail: e.message };
+  }
+
+  persistStderr(outputDir, instanceId, execId, stderr);
+  return { success, fatal: false, detail: success ? "" : `脚本退出码 ${exitCode}` };
+}
+
+function persistStderr(outputDir, instanceId, execId, stderr) {
+  if (!stderr) return;
+  try {
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(outputDir, outputNodeBasename(instanceId, execId, "stderr")),
+      stderr,
+      "utf-8",
+    );
+  } catch (_) {}
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const sep = args.indexOf("--");
+  if (sep < 0 || args.length < sep + 2) {
+    console.error(
+      "Usage: node run-tool-nodejs.mjs <workspaceRoot> <flowName> <uuid> <instanceId> [execId] -- <scriptCmd> [args...]",
+    );
+    process.exit(2);
+  }
+
+  const workspaceRoot = path.resolve(args[0]);
+  const flowName = args[1];
+  const uuid = args[2];
+  const instanceId = args[3];
+  const execId =
+    sep >= 5 && args[4] !== "--"
+      ? (parseInt(String(args[4]), 10) || 1)
+      : loadExecId(workspaceRoot, flowName, uuid, instanceId);
+  const scriptArgs = args.slice(sep + 1);
+
+  for (let attempt = 1; attempt <= MAX_RETRIES + 1; attempt++) {
+    const result = runOnce(workspaceRoot, flowName, uuid, instanceId, execId, scriptArgs);
+    if (result.success) {
+      process.exit(0);
+    }
+    if (result.fatal) {
+      console.error(result.detail);
+      process.exit(1);
+    }
+    if (attempt <= MAX_RETRIES) {
+      console.error(`[tool_nodejs 自愈] ${instanceId} 第 ${attempt}/${MAX_RETRIES} 次重试：${result.detail?.slice(0, 200) || "unknown"}`);
+      spawnSync("sleep", [String(RETRY_DELAY_MS / 1000)], { stdio: "ignore" });
+    } else {
+      console.error(result.detail);
+      process.exit(1);
+    }
+  }
+}
+
+main();

package/bin/pipeline/save-key.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * tool_save_key 执行脚本：按 key 将 value 写入 run 目录下 memory 存储，stdout 输出 tool_nodejs 约定 JSON。
+ * 存储路径与格式由本脚本内部实现，节点不感知。key/value 由命令行参数传入，不读 flow。
+ * value 若为 run 目录内相对路径则读取文件内容后写入。
+ * 用法：node save-key.mjs <workspaceRoot> <flowName> <uuid> <key> [value]
+ * 输出（stdout 一行 JSON）：成功时 result 为写入的 value；err_code 0=成功 1=失败，无 next。
+ */
+
+import fs from "fs";
+import path from "path";
+
+import { getRunDir } from "../lib/paths.mjs";
+
+const MEMORY_FILENAME = "memory.md";
+
+function parseMemory(content) {
+  const map = new Map();
+  for (const line of (content || "").split(/\r?\n/)) {
+    const idx = line.indexOf(": ");
+    if (idx <= 0) continue;
+    const k = line.slice(0, idx).trim();
+    const v = line.slice(idx + 2).trim();
+    if (k) map.set(k, v);
+  }
+  return map;
+}
+
+function serializeMemory(map) {
+  return (
+    Array.from(map.entries())
+      .map(([k, v]) => `${k}: ${String(v).replace(/\r?\n/g, " ")}`)
+      .join("\n") + (map.size ? "\n" : "")
+  );
+}
+
+function main() {
+  const [root, flowName, uuid, keyArg, valueArg] = process.argv.slice(2);
+  if (!root || !flowName || !uuid) {
+    console.log(
+      JSON.stringify({
+        err_code: 1,
+        message: { result: "" },
+      }),
+    );
+    process.exit(0);
+  }
+
+  const key = keyArg != null ? String(keyArg).trim() : "";
+  let value = valueArg != null ? String(valueArg).trim() : "";
+
+  const workspaceRoot = path.resolve(root);
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const memoryPath = path.join(runDir, MEMORY_FILENAME);
+
+  if (!key) {
+    console.log(
+      JSON.stringify({
+        err_code: 0,
+        message: { result: "" },
+      }),
+    );
+    process.exit(0);
+  }
+
+  if (
+    value &&
+    (value.includes("/") || value.startsWith("output") || value.startsWith("intermediate"))
+  ) {
+    const valuePath = path.join(runDir, value);
+    if (fs.existsSync(valuePath)) {
+      try {
+        value = fs.readFileSync(valuePath, "utf-8").trim();
+      } catch (_) {}
+    }
+  }
+
+  const existing = fs.existsSync(memoryPath)
+    ? parseMemory(fs.readFileSync(memoryPath, "utf-8"))
+    : new Map();
+  existing.set(key, value);
+  fs.mkdirSync(path.dirname(memoryPath), { recursive: true });
+  fs.writeFileSync(memoryPath, serializeMemory(existing), "utf-8");
+
+  console.log(
+    JSON.stringify({
+      err_code: 0,
+      message: { result: value },
+    }),
+  );
+}
+
+main();

package/bin/pipeline/snapshot-prior-round.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * 节点每轮执行进入 pre-process 时，统一把「上一轮遗留的当前文件」快照到
+ *   <name>_<priorExecId>.<ext>
+ * 形式。这是唯一的备份入口，替代分散在 write-result / build-node-prompt /
+ * pre-process 内多种辅助 prompt / get-env / run-tool-nodejs 中的 rename 调用。
+ *
+ * 不变量：
+ *   1. 文件后缀 `_K` 严格对应「第 K 轮结束时的文件内容」，无错位。
+ *   2. unsuffixed（无 `_N` 后缀）= 当前最新版本，永远存在；snapshot 用 copy
+ *      生成 `_K` 历史快照，不破坏 unsuffixed。下游运行时只 resolve unsuffixed，
+ *      不应也不需要 fallback 到 `_K`。
+ *   3. 幂等：目标 `_K.ext` 已存在或源文件已经是 `_K.ext` 形态，直接跳过。
+ *
+ * 调用方：bin/pipeline/pre-process-node.mjs 在计算 execId 后、任何 write 前。
+ */
+import fs from "fs";
+import path from "path";
+
+import { intermediateDirForNode, outputDirForNode } from "./get-exec-id.mjs";
+
+const BACKUP_SUFFIX_RE = /_\d+$/;
+
+/**
+ * @param {string} runDir - .workspace/agentflow/runBuild/<flowName>/<uuid>
+ * @param {string} instanceId
+ * @param {number} priorExecId - memory 里记录的「上一轮已完成 execId」，首轮传 0/undefined 直接返回
+ */
+export function snapshotPriorRoundIfNeeded(runDir, instanceId, priorExecId) {
+  const prior = Number(priorExecId);
+  if (!Number.isFinite(prior) || prior < 1) return;
+  const suffix = `_${prior}`;
+
+  const interDir = path.join(runDir, intermediateDirForNode(instanceId));
+  snapshotDir(interDir, (f) => f.startsWith(instanceId + "."), suffix);
+
+  const outDir = path.join(runDir, outputDirForNode(instanceId));
+  snapshotDir(outDir, (f) => f.startsWith(`node_${instanceId}_`), suffix);
+}
+
+/**
+ * @param {string} dir
+ * @param {(filename: string) => boolean} predicate
+ * @param {string} suffix - `_<N>`
+ */
+function snapshotDir(dir, predicate, suffix) {
+  if (!fs.existsSync(dir)) return;
+  let files;
+  try {
+    files = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const f of files) {
+    if (!predicate(f)) continue;
+    const ext = path.extname(f);
+    const base = path.basename(f, ext);
+    // 已是备份文件（以 _\d+ 结尾），跳过
+    if (BACKUP_SUFFIX_RE.test(base)) continue;
+    const to = base + suffix + ext;
+    if (to === f) continue;
+    const toPath = path.join(dir, to);
+    if (fs.existsSync(toPath)) continue; // 幂等
+    try {
+      fs.copyFileSync(path.join(dir, f), toPath);
+    } catch {
+      // 并发或权限错误：放弃该文件，其它继续。unsuffixed 保留不动。
+    }
+  }
+}