@fieldwangai/agentflow 0.1.153 → 0.1.154

package/bin/lib/node-package-bootstrap.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * 代码节点包的执行入口。
+ *
+ * 由 `workspaceMarketplaceRuntimeCommand` 生成的命令调用：
+ *
+ *     node <此文件> <entryAbs>
+ *
+ * 节点包的 `index.mjs` 是个 **模块**，不是脚本——直接 `node index.mjs` 只会定义完就退出。
+ * 这里负责把 Workspace 运行时的环境契约翻译成 `run()` 的三个参数：
+ *
+ *   inputs   来自 AGENTFLOW_INPUTS_JSON，按槽位名取值
+ *   outputs  来自 AGENTFLOW_OUTPUTS_ABS_JSON，槽位名 -> 该写入的绝对路径
+ *   dirs     workspaceRoot / nodeRunDir / nodeTmpDir / outputsDir
+ *
+ * 约定与 tool_nodejs 一致：退出码即成败，stdout 即节点 result，不做 JSON 包装。
+ */
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+function parseJsonEnv(name) {
+  const raw = process.env[name];
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+const entry = process.argv[2];
+if (!entry) {
+  console.error("node-package-bootstrap: 缺少入口文件参数");
+  process.exit(2);
+}
+
+const entryAbs = path.resolve(entry);
+let mod;
+try {
+  mod = await import(pathToFileURL(entryAbs).href);
+} catch (e) {
+  console.error(`节点包入口加载失败 ${entryAbs}: ${(e && e.stack) || e}`);
+  process.exit(1);
+}
+
+const run = typeof mod.run === "function"
+  ? mod.run
+  : typeof mod.default?.run === "function"
+    ? mod.default.run
+    : null;
+if (!run) {
+  console.error(`节点包 ${entryAbs} 没有导出 run()；请 \`export async function run(inputs, outputs, dirs)\``);
+  process.exit(1);
+}
+
+const inputs = parseJsonEnv("AGENTFLOW_INPUTS_JSON");
+const outputs = parseJsonEnv("AGENTFLOW_OUTPUTS_ABS_JSON");
+const dirs = {
+  workspaceRoot: process.env.AGENTFLOW_WORKSPACE_ROOT || process.cwd(),
+  nodeRunDir: process.env.AGENTFLOW_NODE_RUN_DIR || process.cwd(),
+  nodeTmpDir: process.env.AGENTFLOW_NODE_TMP_DIR || process.cwd(),
+  outputsDir: process.env.AGENTFLOW_OUTPUTS_DIR || process.cwd(),
+};
+
+try {
+  await run(inputs, outputs, dirs);
+} catch (e) {
+  // 节点靠抛错来失败；把栈打到 stderr，退出码非零
+  console.error((e && e.stack) || String(e));
+  process.exit(1);
+}

package/bin/lib/node-package-manifest.mjs

@@ -0,0 +1,174 @@
+/**
+ * 代码节点包的清单提取。
+ *
+ * 一个节点包 = 一个目录，`index.mjs` 同时是「声明」和「实现」：
+ *
+ * ```js
+ * export default {
+ *   id: "collect_metrics",
+ *   version: "1.0.0",
+ *   name: "统计流程语料",
+ *   inputs:  { date: { type: "text", description: "查询日期" } },
+ *   outputs: { result: { type: "text" } },
+ * };
+ *
+ * export async function run(inputs, outputs, dirs) { ... }
+ * ```
+ *
+ * 声明部分由 acorn **静态解析**得到——列节点面板、校验槽位、渲染画布都不会执行包里的
+ * 代码。这是硬约束：目录扫描期执行第三方代码既慢又不安全。
+ *
+ * 代价是 `export default` 必须是纯字面量。任何变量引用、函数调用、展开运算都会被拒绝，
+ * 并给出明确报错，而不是悄悄退化成空清单。
+ */
+import fs from "fs";
+import path from "path";
+import { parse as acornParse } from "acorn";
+
+export const NODE_PACKAGE_ENTRY = "index.mjs";
+
+/** 槽位类型；与 builtin/nodes/*.md 的 `type:` 取值一致。 */
+const SLOT_TYPES = new Set(["text", "file", "bool", "node", "image", "json"]);
+
+function staticEval(node, where) {
+  if (!node) throw new Error(`${where}: 空表达式`);
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "TemplateLiteral":
+      if (node.expressions.length) throw new Error(`${where}: 模板字符串不能有插值`);
+      return node.quasis.map((q) => q.value.cooked).join("");
+    case "ArrayExpression":
+      return node.elements.map((el, i) => staticEval(el, `${where}[${i}]`));
+    case "ObjectExpression": {
+      const out = {};
+      for (const prop of node.properties) {
+        if (prop.type !== "Property") throw new Error(`${where}: 对象里不允许展开运算符`);
+        if (prop.computed) throw new Error(`${where}: 对象里不允许计算属性名`);
+        const key = prop.key.type === "Identifier" ? prop.key.name : prop.key.value;
+        out[key] = staticEval(prop.value, `${where}.${key}`);
+      }
+      return out;
+    }
+    case "UnaryExpression":
+      if (node.operator === "-") return -staticEval(node.argument, where);
+      if (node.operator === "+") return +staticEval(node.argument, where);
+      throw new Error(`${where}: 不允许的一元运算 ${node.operator}`);
+    default:
+      throw new Error(`${where}: 只允许字面量，不允许 ${node.type}`);
+  }
+}
+
+/**
+ * 从节点包入口静态提取 `export default` 声明。
+ * @returns {object|null} 解析不出声明时返回 null；语法/字面量违规时抛错。
+ */
+export function readNodePackageDeclaration(entryPath) {
+  const src = fs.readFileSync(entryPath, "utf-8");
+  let ast;
+  try {
+    ast = acornParse(src, { ecmaVersion: 2022, sourceType: "module" });
+  } catch (e) {
+    throw new Error(`${path.basename(entryPath)} 解析失败：${(e && e.message) || e}`);
+  }
+  for (const stmt of ast.body) {
+    if (stmt.type !== "ExportDefaultDeclaration") continue;
+    return staticEval(stmt.declaration, "export default");
+  }
+  return null;
+}
+
+/** 入口是否导出了 `run`（命名导出或 `export default { run }` 之外的函数声明）。 */
+export function nodePackageExportsRun(entryPath) {
+  const src = fs.readFileSync(entryPath, "utf-8");
+  let ast;
+  try {
+    ast = acornParse(src, { ecmaVersion: 2022, sourceType: "module" });
+  } catch {
+    return false;
+  }
+  for (const stmt of ast.body) {
+    if (stmt.type !== "ExportNamedDeclaration") continue;
+    const decl = stmt.declaration;
+    if (decl?.type === "FunctionDeclaration" && decl.id?.name === "run") return true;
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations) if (d.id?.type === "Identifier" && d.id.name === "run") return true;
+    }
+    for (const spec of stmt.specifiers || []) {
+      const exported = spec.exported?.name ?? spec.exported?.value;
+      if (exported === "run") return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 声明里的 `inputs` / `outputs` 是对象映射（顺序即槽位顺序）；平台要的是槽位数组，
+ * 且首位固定是控制槽 prev / next。
+ */
+export function slotMapToList(map, kind) {
+  const first = kind === "input"
+    ? { type: "node", name: "prev", default: "" }
+    : { type: "node", name: "next", default: "" };
+  const out = [first];
+  if (!map || typeof map !== "object" || Array.isArray(map)) return out;
+  for (const [name, rawSpec] of Object.entries(map)) {
+    const spec = typeof rawSpec === "string" ? { type: rawSpec } : (rawSpec && typeof rawSpec === "object" ? rawSpec : {});
+    const type = String(spec.type || "text").trim();
+    if (!SLOT_TYPES.has(type)) {
+      throw new Error(`${kind} 槽位 ${name}: 未知类型 ${type}（可选 ${[...SLOT_TYPES].join(" / ")}）`);
+    }
+    const slot = { type, name: String(name), default: spec.default == null ? "" : String(spec.default) };
+    if (spec.description != null) slot.description = String(spec.description);
+    if (spec.required != null) slot.required = Boolean(spec.required);
+    out.push(slot);
+  }
+  return out;
+}
+
+/**
+ * 把节点包声明转成 marketplace manifest 的形状（`node.yaml` 解析后的等价物）。
+ * @returns {object|null}
+ */
+export function nodePackageDeclarationToManifest(decl, packageDir) {
+  if (!decl || typeof decl !== "object" || Array.isArray(decl)) return null;
+  const id = decl.id != null ? String(decl.id).trim() : path.basename(packageDir);
+  const version = decl.version != null ? String(decl.version).trim() : "";
+  if (!id || !version) return null;
+  return {
+    id,
+    version,
+    displayName: decl.name != null ? String(decl.name) : id,
+    description: decl.description != null ? String(decl.description) : "",
+    input: slotMapToList(decl.inputs, "input"),
+    output: slotMapToList(decl.outputs, "output"),
+    baseDefinitionId: "tool_nodejs",
+    runtime: { type: "tool_nodejs", entry: NODE_PACKAGE_ENTRY, mode: "module" },
+    ...(decl.ownerUserId != null ? { ownerUserId: String(decl.ownerUserId) } : {}),
+    ...(decl.createdBy != null ? { createdBy: String(decl.createdBy) } : {}),
+  };
+}
+
+/**
+ * 读取一个节点包目录的清单：优先 `index.mjs` 静态声明，读不出再回退调用方给的
+ * `node.yaml` 读取器。
+ * @param {string} dir
+ * @param {(yamlPath: string) => object|null} readYaml
+ * @returns {object|null}
+ */
+export function readNodePackageManifest(dir, readYaml) {
+  const entry = path.join(dir, NODE_PACKAGE_ENTRY);
+  if (fs.existsSync(entry) && fs.statSync(entry).isFile()) {
+    const manifest = nodePackageDeclarationToManifest(readNodePackageDeclaration(entry), dir);
+    if (manifest) return manifest;
+  }
+  return typeof readYaml === "function" ? readYaml(path.join(dir, "node.yaml")) : null;
+}
+
+/** 目录是否是一个可识别的节点包。 */
+export function isNodePackageDir(dir) {
+  if (!dir || !fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return false;
+  const entry = path.join(dir, NODE_PACKAGE_ENTRY);
+  if (fs.existsSync(entry) && fs.statSync(entry).isFile()) return true;
+  return fs.existsSync(path.join(dir, "node.yaml"));
+}

package/bin/lib/paths.mjs

@@ -14,6 +14,44 @@ export const PACKAGE_ROOT = path.resolve(BIN_DIR, "..");
 /** 节点执行区域分割线（开始/结束标识用） */
 export const NODE_SEP = "════════════════════════════════════════════════════════════════";
 
+/**
+ * 「这个目录是不是一个流程」的**唯一**判据。
+ *
+ * 历史上这条规则在十来处各写了一遍 `existsSync(dir + "/flow.yaml")`，于是 `flow.yaml`
+ * 从执行格式悄悄退化成了目录哨兵：内容早就是死的，存在却是承重的——没有它，目录在列表、
+ * 路径解析、复制改名里全都不存在。
+ *
+ * 顺序即权威顺序：代码 > 只读的遗留 JSON > 已退休的 flow.yaml。
+ */
+export const FLOW_MARKER_FILENAMES = ["workspace.flow.js", "workspace.graph.json", "flow.yaml"];
+
+/**
+ * 命中的标记文件绝对路径；都没有则空字符串。
+ * @param {string} dir
+ * @returns {string}
+ */
+export function flowMarkerPath(dir) {
+  const base = dir == null ? "" : String(dir).trim();
+  if (!base) return "";
+  for (const name of FLOW_MARKER_FILENAMES) {
+    const p = path.join(base, name);
+    try {
+      if (fs.existsSync(p)) return p;
+    } catch {
+      /* 不可读的目录当作没有 */
+    }
+  }
+  return "";
+}
+
+/**
+ * @param {string} dir
+ * @returns {boolean}
+ */
+export function isFlowDir(dir) {
+  return flowMarkerPath(dir) !== "";
+}
+
 /** agentflow 包根目录（CLI 所在包的 node_modules 用于解析脚本依赖，如 js-yaml） */
 export const PACKAGE_AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
 /** 包内 agents 元数据 JSON */
@@ -142,7 +180,7 @@ export function resolveUniqueUserPipelineDir(flowName) {
   for (const userId of listAgentflowUserIds()) {
     const dir = path.join(getAgentflowDataRoot(), "users", userId, "pipelines", name);
     try {
-      if (fs.existsSync(path.join(dir, "flow.yaml"))) matches.push(dir);
+      if (isFlowDir(dir)) matches.push(dir);
     } catch {
       /* ignore unreadable user dirs */
     }
@@ -178,11 +216,11 @@ export function getFlowRuntimeRoot(workspaceRoot, flowName, opts = {}) {
       : process.cwd();
   const userRoot = getUserPipelinesRoot(opts.userId);
   const userDir = path.join(userRoot, flowName);
-  if (fs.existsSync(path.join(userDir, "flow.yaml"))) return userDir;
+  if (isFlowDir(userDir)) return userDir;
   const inferredUserDir = resolveUniqueUserPipelineDir(flowName);
   if (inferredUserDir) return inferredUserDir;
   const wsDir = path.join(root, PIPELINES_DIR, flowName);
-  if (fs.existsSync(path.join(wsDir, "flow.yaml"))) return wsDir;
+  if (isFlowDir(wsDir)) return wsDir;
   // builtin / legacy / 尚未落盘 → 默认 user 目录，runBuild 首次写入时创建
   return userDir;
 }
@@ -260,23 +298,8 @@ export const USER_AGENTFLOW_AGENTS_LABEL = "~/agentflow/agents";
 /** agents.json 中 user 角色 filepath 展示前缀（相对数据根） */
 export const USER_AGENTS_FILEPATH_PREFIX = "agentflow/agents";
 
-/** apply/replay 流水线脚本目录（随包发布） */
+/** 随包发布的 CLI 单步脚本目录（validate-flow / get-ready-nodes / extract-thinking） */
 export const PIPELINE_SCRIPTS_DIR = path.join(BIN_DIR, "pipeline");
-/** apply -ai 允许调用的单步脚本名（不含 .mjs） */
-export const APPLY_AI_STEPS = [
-  "ensure-run-dir",
-  "parse-flow",
-  "get-ready-nodes",
-  "pre-process-node",
-  "post-process-node",
-  "write-result",
-  "run-tool-nodejs",
-  "get-env",
-  "validate-flow",
-  "collect-nodes",
-  "gc",
-  "extract-thinking",
-];
 /** 项目内流水线根目录（写入与主读取路径） */
 export const PIPELINES_DIR = ".workspace/agentflow/pipelines";
 /** 用户目录或工作区 pipelines 下存放已归档流水线的子目录名 */