@ai-setting/roy-agent-core 1.7.53 → 1.7.55

package/dist/shared/@ai-setting/{roy-agent-core-gdsqp6j8.js → roy-agent-core-6masakz4.js}

@@ -1548,6 +1548,28 @@ workflow-creator 是**多轮对话式**协作。每个阶段都可能需要 ask
 - ❌ **禁止**对 \`tool\` 节点写深层路径（如 \`{{nodes.bash-node.output.foo}}\`）—— tool 输出常是字符串，无法再取属性
 - ✅ 存疑时一律退回 \`.output\`，或用 \`{{nodes.X.output}}\` 打印后**人肉核对**
 
+### 阶段 4.6: 单节点冒烟前置 (Per-node Standalone Smoke) \uD83E\uDDEA
+
+> **依据 Task #4385 §3.4**：历史失败中，大量节点是**在整条 workflow 里第一次被执行**的 ——
+> 脚本名拼错、产物目录不存在、命令依赖 \`cd\`、参数没传进去…… 一个坏节点就烧掉整轮 run，
+> 然后你在整条链路的噪音里排障。**先把每个节点单独跑通，再拼成 DAG。**
+
+**在把 YAML 组装/注册之前，对每一个 \`tool\` / \`pythonCall\` / \`skill\` 节点逐个做单节点冒烟：**
+
+1. 用 \`bash\` 把该节点的 \`config.command\`（或 \`config.script\` / \`args\`）**原样**执行一次。
+   - 变量先替换成真实值再跑（不要留着 \`{{input.x}}\` 跑，那验不出东西）
+   - 逐个节点跑，**不是**跑整条链路
+2. 三项全绿才算该节点通过：
+   - ✅ **exit code = 0**（非 0 立刻停下修，不要往后拼）
+   - ✅ **产物/目录真实存在**（脚本声称会写出的文件、目录、wheel、日志，用 \`ls\` 核实）
+   - ✅ **输出非空且含预期标记**（\`grep\` 你后面要引用的那个标记，命中才算通）
+3. 任何一项红了 → **先修这个节点**（改路径 / 改命令 / 改脚本），修好重跑，**不要**带着红灯继续组装。
+
+**为什么不能省**：\`workflow_validate\` 只校验 DAG 结构 + 模板引用契约，它**看不到**
+"这个 shell 命令在这个 cwd 下到底能不能跑通"。单节点冒烟是唯一廉价、快速、可重复的补位。
+
+**通过后**记录一张自检表（节点 id → exit code / 产物 / 标记），写进最终报告。
+
 ### 阶段 5: 迭代验证 (Iterative Validate) \uD83D\uDD01
 
 调用 \`workflow_validate\`，它返回 \`{ valid, errors, warnings, infos, errorCount, warningCount }\`。
@@ -1601,6 +1623,29 @@ workflow-creator 是**多轮对话式**协作。每个阶段都可能需要 ask
 **未通过冒烟 → 禁止 \`task_complete\`**：回到阶段 4 改 YAML，重跑，直到通过；或明确报告失败原因
 （**不得**用"应该没问题"之类的措辞声称通过）。
 
+#### \uD83D\uDEAB 手动补跑 ≠ 真跑（依据 Task #4385 §3.5）
+
+workflow run 失败后，**手动**把某个节点的命令再敲一遍、看到它成功了，**不算**该节点被验证。
+
+- ❌ 手动补跑的结果**不得计入** PASS 计数，也**不得**作为 "节点没问题" 的依据
+- ❌ 不得因为"手动跑通了"就跳过修 YAML / 重跑 workflow
+- ✅ 手动作业只能用来**定位原因**；结论必须靠**重跑 workflow** 得出
+- ✅ 若最终确实没能在 workflow 内验证某节点，结论里必须显式标注
+  **「⚠️ 该节点未经 workflow run 验证」**，与真正通过的节点分开列
+
+> 为什么：手动跑不经过模板解析、依赖排序、引擎超时与 fail-fast。
+> 一条在 shell 里通的命令，在节点里完全可能因为 \`{{}}\` 解析成空串而"成功但空转"。
+
+#### \uD83D\uDD0D 归因：先分清「超时」与「别的节点先 fail-fast」（依据 Task #4385 §5）
+
+说"某个节点超时了"之前，**必须先证明没有其他节点先失败**。
+
+- 引擎是 **fail-fast** 的：任一节点失败会立刻收尾整个 run，**尚未跑完的节点看起来就像"卡住/超时"**
+- 因此**先排除**：\`roy-agent debug trace <trace_id>\` 里是否已有**其它节点**的失败 span / error
+- 只有在确认 "无其它节点先失败" 之后，才可以判断为真超时，再去看该节点自己的 span 耗时与 stdout
+- ❌ 不要把 fail-fast 的连带中止当成超时去"修超时参数" —— 这会让你在错误的节点上白改几轮
+  （历史教训：#4361 / #4366 连续两轮误判）
+
 > \uD83D\uDEAB **绝不允许用 \`workflow update\` 绕过冒烟验证**（历史上真实节点版本 v1.1.0/v1.2.0 就是走
 > \`workflow update\` 注册的，完全绕过了 validate 与冒烟）。update 后**同样必须**重跑阶段 5 + 5.5。
 

package/dist/shared/@ai-setting/{roy-agent-core-vvxb9522.js → roy-agent-core-6qxh4xrm.js}

@@ -1,13 +1,13 @@
 import {
   isValidSessionId
-} from "./roy-agent-core-yd21n6c7.js";
+} from "./roy-agent-core-zvemdfx5.js";
 import {
   TAG_MAX_COUNT,
   TAG_MIN_COUNT
 } from "./roy-agent-core-7evvpfwc.js";
 import {
   validateWorkflowDefinition
-} from "./roy-agent-core-na73mym1.js";
+} from "./roy-agent-core-a4vzsn0g.js";
 import {
   getCurrentBgTaskId
 } from "./roy-agent-core-c1v263jn.js";
@@ -24,7 +24,8 @@ import {
   init_logger
 } from "./roy-agent-core-8seq65bp.js";
 import {
-  __legacyDecorateClassTS
+  __legacyDecorateClassTS,
+  __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/workflow/tools/ask-user-tool.ts
@@ -480,8 +481,25 @@ var logger5 = createLogger("workflow-validate-tool");
 var WorkflowValidateInputSchema = z6.object({
   definition: z6.any().optional().describe("Workflow definition object (alternative to definition_yaml)"),
   definition_yaml: z6.string().optional().describe("Workflow definition as YAML or JSON string"),
-  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string")
+  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string"),
+  file: z6.string().optional().describe("Path to a YAML/JSON file to validate. Use this INSTEAD of passing " + "`$(cat /path)` — shell substitutions are NOT expanded by this tool.")
 });
+function isAllowedPath(absPath) {
+  const cwd = process.cwd();
+  const normalized = absPath.replace(/\\/g, "/");
+  if (normalized === cwd || normalized.startsWith(`${cwd}/`))
+    return true;
+  if (normalized === "/tmp" || normalized.startsWith("/tmp/"))
+    return true;
+  return false;
+}
+function detectShellSubstitution(text) {
+  const trimmed = text.trim();
+  const looksLikeSubstitution = /^\$\(.*\)$/.test(trimmed) || /^`.*`$/.test(trimmed) || /\$\(\s*cat\s+/.test(trimmed) || /`\s*cat\s+/.test(trimmed);
+  if (!looksLikeSubstitution)
+    return;
+  return "Shell substitutions such as `$(cat /path)` are NOT expanded by this tool — the " + "string is passed to the YAML parser verbatim, which is why you saw " + "`Parsed definition is not an object`. Pass the path directly instead: " + 'workflow_validate({ file: "/tmp/x.yaml" }).';
+}
 function createWorkflowValidateTool(_workflowService) {
   return {
     name: "workflow_validate",
@@ -493,13 +511,56 @@ function createWorkflowValidateTool(_workflowService) {
         let definition;
         if (params.definition && typeof params.definition === "object") {
           definition = params.definition;
+        } else if (params.file && typeof params.file === "string") {
+          const fs = await import("node:fs/promises");
+          const nodePath = await import("node:path");
+          const abs = nodePath.resolve(params.file);
+          if (!isAllowedPath(abs)) {
+            return {
+              success: false,
+              output: "",
+              error: `Refusing to read outside the working directory or /tmp: ${abs}. Copy the file into CWD or /tmp first.`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          let raw;
+          try {
+            raw = await fs.readFile(abs, "utf-8");
+          } catch (readErr) {
+            const code = readErr?.code;
+            return {
+              success: false,
+              output: "",
+              error: code === "ENOENT" ? `Workflow file not found: ${abs}. Check the path (it is resolved against CWD: ${process.cwd()}).` : `Failed to read workflow file ${abs}: ${readErr instanceof Error ? readErr.message : String(readErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          try {
+            definition = yaml2.parse(raw);
+          } catch (yamlErr) {
+            return {
+              success: false,
+              output: "",
+              error: `Invalid YAML in ${abs}: ${yamlErr instanceof Error ? yamlErr.message : String(yamlErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
         } else {
           const yamlText = params.yaml ?? params.definition_yaml;
           if (!yamlText || typeof yamlText !== "string") {
             return {
               success: false,
               output: "",
-              error: "Must provide either 'definition' (object), 'definition_yaml', or 'yaml' (string)",
+              error: "Must provide either 'definition' (object), 'file' (path), 'definition_yaml', or 'yaml' (string)",
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          const substitutionHint = detectShellSubstitution(yamlText);
+          if (substitutionHint) {
+            return {
+              success: false,
+              output: "",
+              error: substitutionHint,
               metadata: { execution_time_ms: 0 }
             };
           }
@@ -518,7 +579,7 @@ function createWorkflowValidateTool(_workflowService) {
           return {
             success: false,
             output: "",
-            error: "Parsed definition is not an object",
+            error: `Parsed definition is not an object (got ${definition === null ? "null" : typeof definition}). If you passed a file path as a string, use workflow_validate({ file: "/path/to.yaml" }) ` + "instead of embedding `$(cat ...)` — shell substitutions are not expanded here.",
             metadata: { execution_time_ms: 0 }
           };
         }

package/dist/shared/@ai-setting/{roy-agent-core-h93v6p6y.js → roy-agent-core-7qy3nffr.js}

@@ -1,9 +1,9 @@
 import {
   SessionMessageConverter
-} from "./roy-agent-core-pk1b3kvf.js";
+} from "./roy-agent-core-2b8jtv7m.js";
 import {
   canonicalizeParts
-} from "./roy-agent-core-zy3hqfwg.js";
+} from "./roy-agent-core-0hq21px2.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-4vpk40ss.js → roy-agent-core-8eqngasy.js}

@@ -13,7 +13,7 @@ import {
   createWorkflowSearchTool,
   createWorkflowTagListTool,
   createWorkflowValidateTool
-} from "./roy-agent-core-vvxb9522.js";
+} from "./roy-agent-core-6qxh4xrm.js";
 import {
   WorkflowService
 } from "./roy-agent-core-7evvpfwc.js";
@@ -21,7 +21,7 @@ import {
   WorkflowEngine,
   exports_engine,
   init_engine
-} from "./roy-agent-core-35s1w7tc.js";
+} from "./roy-agent-core-aer5kw1j.js";
 import {
   BaseComponent
 } from "./roy-agent-core-tdbv7ff4.js";

package/dist/shared/@ai-setting/{roy-agent-core-brwzs8wf.js → roy-agent-core-9h72sk1n.js}

@@ -1,7 +1,7 @@
 import {
   LarkCardPatchNotifier,
   formatDurationMs
-} from "./roy-agent-core-j8e92gj8.js";
+} from "./roy-agent-core-b5ew8t0k.js";
 import {
   WorkflowHookPoints,
   init_workflow_hook_points

package/dist/shared/@ai-setting/{roy-agent-core-na73mym1.js → roy-agent-core-a4vzsn0g.js}

@@ -315,6 +315,167 @@ function formatTemplateContractFindings(findings) {
 
 // src/env/workflow/utils/validate-workflow-definition.ts
 init_dag_manager();
+
+// src/env/workflow/utils/shell-dialect-lint.ts
+var RULES = [
+  {
+    name: "pipefail",
+    re: /\bset\s+(?:-[A-Za-z]+\s+)*-?[A-Za-z]*o[A-Za-z]*\s+pipefail\b/,
+    fix: "dash 不支持 set -o pipefail（含 set -euo pipefail）。改用落文件再取退出码: " + "`cmd > /tmp/o 2>&1; RC=$?; cat /tmp/o; exit $RC`"
+  },
+  {
+    name: "PIPESTATUS",
+    re: /\$\{PIPESTATUS\[/,
+    fix: "dash 不支持 ${PIPESTATUS[n]}。改用把管道左端输出落文件，再单独取 $?: " + "`cmd > /tmp/o 2>&1; RC=$?`"
+  },
+  {
+    name: "substring-replace",
+    re: /\$\{[A-Za-z_][A-Za-z0-9_]*\/\//,
+    fix: "dash 不支持 ${VAR//a/b}。改用 tr 或 sed: " + '`V=$(echo "$V" | tr -d ".")`'
+  },
+  {
+    name: "BASH_SOURCE",
+    re: /\$\{BASH_SOURCE/,
+    fix: "dash 不支持 ${BASH_SOURCE[0]}。改用 $0（或显式写绝对路径）"
+  },
+  {
+    name: "process-substitution",
+    re: /(?:^|[\s;&|(])[<>]\([^)]/,
+    fix: "dash 不支持进程替换 <(cmd) / >(cmd)。改用显式 bash 或临时文件: " + "`bash -c 'diff <(a) <(b)'` 或 `a > /tmp/a; b > /tmp/b; diff /tmp/a /tmp/b`"
+  },
+  {
+    name: "here-string",
+    re: /(?<!<)<<<\s*[^\s<]/,
+    fix: "dash 不支持 here-string <<<。改用 printf 管道: " + '`printf "%s\\n" "$X" | cmd`'
+  },
+  {
+    name: "ansi-c-quote",
+    re: /\$'(?:[^'\\]|\\.)*\\/,
+    fix: "dash 不支持 ANSI-C 转义 $'...'（会静默保留反斜杠）。改用 printf: " + '`printf "a\\tb\\n"`'
+  },
+  {
+    name: "dbl-bracket",
+    re: /\[\[(?=[\s\-!$\u0027])/,
+    fix: 'dash 不支持 [[ ]]。改用 [ ]（注意 quote 变量: `[ -f "$F" ]`）'
+  },
+  {
+    name: "source",
+    re: /(?:^|[\s;&|(])source\s+(?:~|\$|\.|\/)[^\s;|&]*|(?:^|[\s;&|(])source\s+[A-Za-z0-9_.-]+\.sh\b/,
+    fix: "dash 不支持 source。改用 POSIX 点命令: `. <file>`"
+  },
+  {
+    name: "array",
+    re: /(^|[\s;&|(])([A-Za-z_][A-Za-z0-9_]*)=\(/,
+    fix: "dash 不支持数组。改用空格分隔的字符串 + for 循环: " + '`PYS="3.12 3.13"; for p in $PYS; do ...; done`'
+  },
+  {
+    name: "function-keyword",
+    re: /(^|\n)[ \t]*function\s+[A-Za-z_]/,
+    fix: "dash 不支持 function 关键字。改用 `name() { ... }`"
+  },
+  {
+    name: "RANDOM",
+    re: /\$RANDOM\b/,
+    fix: "dash 不支持 $RANDOM（静默为空）。改用 " + "`awk -v s=$(date +%s%N) 'BEGIN{srand(s); print int(rand()*32768)}'`"
+  },
+  {
+    name: "echo-e",
+    re: /(^|[\s;&|(])echo\s+-[ne]*e[A-Za-z]*\b/,
+    fix: 'dash 的 echo 不解析 -e（会输出字面 "-e"）。改用 printf: `printf "%s\\n" "$X"`'
+  }
+];
+function stripComments(command) {
+  const lines = command.split(`
+`);
+  const out = [];
+  for (const line of lines) {
+    let inSingle = false;
+    let inDouble = false;
+    let cut = -1;
+    for (let i = 0;i < line.length; i++) {
+      const ch = line[i];
+      if (ch === "\\" && !inSingle) {
+        i++;
+        continue;
+      }
+      if (ch === "'" && !inDouble) {
+        inSingle = !inSingle;
+        continue;
+      }
+      if (ch === '"' && !inSingle) {
+        inDouble = !inDouble;
+        continue;
+      }
+      if (ch === "#" && !inSingle && !inDouble) {
+        const prev = i === 0 ? " " : line[i - 1];
+        if (/\s/.test(prev)) {
+          cut = i;
+          break;
+        }
+      }
+    }
+    out.push(cut >= 0 ? line.slice(0, cut) : line);
+  }
+  return out.join(`
+`);
+}
+function stripQuotedHeredocBodies(command) {
+  const lines = command.split(`
+`);
+  const out = [];
+  let delim = null;
+  for (const line of lines) {
+    if (delim !== null) {
+      if (line.trim() === delim) {
+        out.push(line);
+        delim = null;
+      }
+      continue;
+    }
+    const m = /<<-?\s*(?:'([^']+)'|"([^"]+)")/.exec(line);
+    out.push(line);
+    if (m)
+      delim = (m[1] ?? m[2] ?? "").trim();
+  }
+  return out.join(`
+`);
+}
+function stripForeignShellBodies(command) {
+  const re = /(\b(?:bash|sh)\s+-[a-z]*c[a-z]*\s+)(?:'[\s\S]*?'|"[\s\S]*?")/g;
+  return command.replace(re, "$1<foreign-shell-body>");
+}
+function isEntirelyBashInvocation(command) {
+  const re = /^(?:[A-Za-z_][A-Za-z0-9_]*=[^\s;|&]*\s+)*\/?(?:[\w./-]*\/)?bash\s+-(?:[a-z]*c[a-z]*)\s+(?:'[\s\S]*'|"[\s\S]*")\s*$/;
+  return re.test(command.trim());
+}
+function lintShellDialect(command) {
+  if (!command || typeof command !== "string")
+    return [];
+  const scannable = stripComments(stripForeignShellBodies(stripQuotedHeredocBodies(command)));
+  if (scannable.trim().length === 0)
+    return [];
+  if (isEntirelyBashInvocation(scannable))
+    return [];
+  const findings = [];
+  const seen = new Set;
+  for (const rule of RULES) {
+    if (seen.has(rule.name))
+      continue;
+    const m = rule.re.exec(scannable);
+    if (!m)
+      continue;
+    seen.add(rule.name);
+    const start = Math.max(0, m.index - 30);
+    const excerpt = scannable.slice(start, m.index + m[0].length + 40).replace(/\s+/g, " ").trim();
+    findings.push({ name: rule.name, fix: rule.fix, excerpt });
+  }
+  return findings;
+}
+function formatShellDialectFindings(nodeId, findings) {
+  return findings.map((f) => `[shell-dialect] node "${nodeId}" uses bash-only "${f.name}": ${f.fix} | near: ${f.excerpt}`);
+}
+
+// src/env/workflow/utils/validate-workflow-definition.ts
 function validateWorkflowDefinition(definition, options = {}) {
   if (!definition || typeof definition !== "object") {
     return {
@@ -352,8 +513,17 @@ function validateWorkflowDefinition(definition, options = {}) {
   const contractErrors = findings.filter((f) => f.severity === "error");
   const contractWarnings = findings.filter((f) => f.severity === "warning");
   const contractInfos = findings.filter((f) => f.severity === "info");
+  const dialectWarnings = [];
+  if (structural.valid && options.lintShellDialect !== false) {
+    try {
+      dialectWarnings.push(...collectShellDialectWarnings(definition));
+    } catch {}
+  }
   const errors = [...structural.errors, ...formatTemplateContractFindings(contractErrors)];
-  const warnings = formatTemplateContractFindings(contractWarnings);
+  const warnings = [
+    ...formatTemplateContractFindings(contractWarnings),
+    ...dialectWarnings
+  ];
   const infos = formatTemplateContractFindings(contractInfos);
   return {
     valid: structural.valid && contractErrors.length === 0,
@@ -363,5 +533,46 @@ function validateWorkflowDefinition(definition, options = {}) {
     ...findings.length > 0 ? { findings } : {}
   };
 }
+function extractToolCommands(config) {
+  if (!config || typeof config !== "object")
+    return [];
+  const out = [];
+  const COMMAND_KEYS = ["command", "cmd"];
+  const CONTAINER_KEYS = ["input", "inputs", "args"];
+  for (const key of COMMAND_KEYS) {
+    const v = config[key];
+    if (typeof v === "string")
+      out.push(v);
+  }
+  for (const key of CONTAINER_KEYS) {
+    const container = config[key];
+    if (!container || typeof container !== "object" || Array.isArray(container))
+      continue;
+    for (const cmdKey of COMMAND_KEYS) {
+      const v = container[cmdKey];
+      if (typeof v === "string")
+        out.push(v);
+    }
+  }
+  return out;
+}
+function collectShellDialectWarnings(definition) {
+  const def = definition;
+  if (!def || !Array.isArray(def.nodes))
+    return [];
+  const warnings = [];
+  for (const node of def.nodes) {
+    if (node?.type !== "tool")
+      continue;
+    const nodeId = typeof node.id === "string" ? node.id : String(node.id ?? "<unnamed>");
+    for (const command of extractToolCommands(node.config)) {
+      const findings = lintShellDialect(command);
+      if (findings.length > 0) {
+        warnings.push(...formatShellDialectFindings(nodeId, findings));
+      }
+    }
+  }
+  return warnings;
+}
 
 export { VIRTUAL_OUTPUT_FIELD, NODE_OUTPUT_CONTRACTS, getNodeOutputContract, hasClosedOutputContract, RESULT_INVALID_NODE_TYPES, getAgentDeclaredJsonFields, validateTemplateContracts, getTemplateContractErrors, getTemplateContractWarnings, formatTemplateContractFindings, validateWorkflowDefinition };