@fieldwangai/agentflow 0.1.25

package/bin/lib/node-execute.mjs

@@ -0,0 +1,513 @@
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import { outputNodeBasename, outputDirForNode } from "../pipeline/get-exec-id.mjs";
+import { writeResult } from "../pipeline/write-result.mjs";
+import {
+  runClaudeCodeAgentForNode,
+  runClaudeCodeAgentWithPrompt,
+  runCursorAgentForNode,
+  runCursorAgentWithPrompt,
+  runOpenCodeAgentForNode,
+  runOpenCodeAgentWithPrompt,
+} from "./agent-runners.mjs";
+import { runApiAgentForNode } from "./api-runner.mjs";
+import { log } from "./log.mjs";
+import { LOCAL_ONLY_DEFINITION_IDS, LOCAL_ONLY_TERMINAL_SUCCESS_IDS } from "./paths.mjs";
+import { resolveCliAndModel } from "./model-config.mjs";
+import { parseJsonStdout, runNodeScript } from "./pipeline-scripts.mjs";
+import { emitEvent } from "./run-events.mjs";
+import { getRunDir } from "./workspace.mjs";
+import { nodeToolCommandToArgv } from "./normalize-node-tool-command.mjs";
+import { buildPipelineScriptPathHint } from "./flow-normalize.mjs";
+import { validateAndParse } from "../pipeline/validate-script-output.mjs";
+
+const TOOL_NODEJS_MAX_RETRIES = 3;
+const TOOL_NODEJS_RETRY_DELAY_MS = 1000;
+const AI_HEAL_ENABLED = !(
+  process.env.AGENTFLOW_TOOL_NODEJS_AI_HEAL === "0" ||
+  process.env.AGENTFLOW_TOOL_NODEJS_AI_HEAL === "false"
+);
+
+// ─── AI 自愈：失败后调用 Cursor/OpenCode CLI 修复脚本再重试 ──────────────────
+
+/**
+ * @returns {{ path: string | null, parsed: string | null, reason: "none" | "unparsable" | "not-found" }}
+ */
+function extractScriptPath(resolvedScript) {
+  const { argv } = nodeToolCommandToArgv(resolvedScript);
+  if (argv.length === 0) return { path: null, parsed: null, reason: "unparsable" };
+  const candidate = argv[0];
+  if (!candidate) return { path: null, parsed: null, reason: "unparsable" };
+  const abs = path.isAbsolute(candidate) ? candidate : path.resolve(candidate);
+  if (fs.existsSync(abs)) return { path: abs, parsed: abs, reason: "none" };
+  return { path: null, parsed: abs, reason: "not-found" };
+}
+
+
+function buildHealPrompt(scriptPath, command, errorInfo, scriptContent) {
+  const stderrSlice = (errorInfo.stderr || "").trim().slice(0, 4000) || "(无)";
+  const stdoutSlice = (errorInfo.stdout || "").trim().slice(0, 2000) || "(无)";
+  return [
+    "你是脚本调试助手。以下 Node.js 脚本执行失败，请直接修复脚本文件中的错误。",
+    "",
+    `## 脚本路径\n${scriptPath}`,
+    `## 执行命令\n${command}`,
+    `## 退出码\n${errorInfo.exitCode}`,
+    `## 标准错误 (stderr)\n${stderrSlice}`,
+    `## 标准输出 (stdout)\n${stdoutSlice}`,
+    "## 当前脚本内容",
+    "```javascript",
+    scriptContent.slice(0, 30000),
+    "```",
+    "",
+    "## 修复要求",
+    `1. 直接编辑脚本文件 \`${scriptPath}\` 修复错误`,
+    "2. 保持脚本的输入输出格式不变（stdout：JSON `{\"err_code\":0,\"message\":{...}}` 中 message 的键对应各输出槽位，或纯文本→写入 result）",
+    "3. 只修复导致失败的问题，不做无关改动",
+    "4. 不要创建新文件、不要修改其他文件",
+  ].join("\n");
+}
+
+/**
+ * 调用 Cursor/OpenCode CLI 让 AI 分析 stderr 并修复脚本文件，然后由调用方重新执行。
+ * @returns {Promise<boolean>} 是否成功完成修复（AI 调用无报错即视为成功，实际修复效果由重试验证）
+ */
+async function healToolNodejsWithAI(workspaceRoot, flowName, uuid, instanceId, resolvedScript, errorInfo, cli, model) {
+  const ext = extractScriptPath(resolvedScript);
+  if (!ext.path) {
+    if (ext.reason === "not-found") {
+      log.warn(
+        `[tool_nodejs AI 自愈] 脚本文件不存在，跳过（这是 flow.yaml 模板路径错，非脚本内容错）：` +
+          `${ext.parsed}。建议把 flow.yaml 里 tool_nodejs.script 的 ` +
+          `\`\${workspaceRoot}/.workspace/agentflow/pipelines/\${flowName}/scripts/...\` ` +
+          `改为 \`\${flowDir}/scripts/xxx.mjs\`（兼容 user/workspace/builtin 安装）`,
+      );
+    } else {
+      log.warn(`[tool_nodejs AI 自愈] 无法从命令提取脚本路径，跳过: ${resolvedScript.slice(0, 120)}`);
+    }
+    return false;
+  }
+  const scriptPath = ext.path;
+
+  let scriptContent;
+  try {
+    scriptContent = fs.readFileSync(scriptPath, "utf-8");
+  } catch {
+    log.warn(`[tool_nodejs AI 自愈] 无法读取脚本文件，跳过: ${scriptPath}`);
+    return false;
+  }
+
+  const prompt = buildHealPrompt(scriptPath, resolvedScript, errorInfo, scriptContent);
+  const healCli =
+    cli === "opencode" ? "opencode" : cli === "claude-code" ? "claude-code" : "cursor";
+
+  log.info(`[tool_nodejs AI 自愈] ${instanceId} 调用 ${healCli}${model ? ` (${model})` : ""} 修复 ${path.basename(scriptPath)}`);
+  emitEvent(workspaceRoot, flowName, uuid, {
+    event: "tool-nodejs-ai-heal-start",
+    instanceId,
+    scriptPath,
+    cli: healCli,
+    model: model ?? null,
+  });
+
+  try {
+    if (healCli === "opencode") {
+      const { finished } = runOpenCodeAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined, force: true });
+      await finished;
+    } else if (healCli === "claude-code") {
+      const { finished } = runClaudeCodeAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined });
+      await finished;
+    } else {
+      const { finished } = runCursorAgentWithPrompt(workspaceRoot, prompt, { model: model || undefined });
+      await finished;
+    }
+    log.info(`[tool_nodejs AI 自愈] ${instanceId} AI 修复完成，即将重试脚本`);
+    emitEvent(workspaceRoot, flowName, uuid, {
+      event: "tool-nodejs-ai-heal-done",
+      instanceId,
+      scriptPath,
+    });
+    return true;
+  } catch (healErr) {
+    log.warn(`[tool_nodejs AI 自愈] ${instanceId} AI 修复失败: ${healErr.message?.slice(0, 200) || healErr}`);
+    emitEvent(workspaceRoot, flowName, uuid, {
+      event: "tool-nodejs-ai-heal-failed",
+      instanceId,
+      scriptPath,
+      error: healErr.message?.slice(0, 300) || String(healErr),
+    });
+    return false;
+  }
+}
+
+// ─── 内联执行 + 重试 ────────────────────────────────────────────────────────
+
+/**
+ * tool_nodejs + script 内联执行：直接跑脚本、写 result，无中间进程。
+ * 失败时可通过 AI（Cursor/OpenCode CLI）自动分析 stderr 修复脚本再重试，
+ * 最多重试 TOOL_NODEJS_MAX_RETRIES 次。
+ * 设置 AGENTFLOW_TOOL_NODEJS_AI_HEAL=0 可关闭 AI 自愈回退为简单重试。
+ *
+ * 协议：与 run-tool-nodejs.mjs 一致——validate-script-output 解析 stdout；
+ * JSON 时 message 的每个键写入同名 output 槽位（含 result）；纯文本则等价于 message.result。
+ */
+async function executeToolNodejsInline(workspaceRoot, flowName, uuid, instanceId, resolvedScript, execId, healOptions) {
+  let lastError;
+  for (let attempt = 1; attempt <= TOOL_NODEJS_MAX_RETRIES + 1; attempt++) {
+    try {
+      executeToolNodejsOnce(workspaceRoot, flowName, uuid, instanceId, resolvedScript, execId);
+      return;
+    } catch (err) {
+      lastError = err;
+      if (attempt <= TOOL_NODEJS_MAX_RETRIES) {
+        const tag = `[tool_nodejs 自愈] ${instanceId} 第 ${attempt}/${TOOL_NODEJS_MAX_RETRIES} 次重试`;
+        log.warn(`${tag}：${err.message?.slice(0, 200) || err}`);
+        emitEvent(workspaceRoot, flowName, uuid, {
+          event: "tool-nodejs-retry",
+          instanceId,
+          attempt,
+          maxRetries: TOOL_NODEJS_MAX_RETRIES,
+          error: err.message?.slice(0, 300) || String(err),
+        });
+
+        if (AI_HEAL_ENABLED && healOptions) {
+          const errorInfo = {
+            stdout: err.scriptStdout || "",
+            stderr: err.scriptStderr || "",
+            exitCode: err.scriptExitCode ?? 1,
+          };
+          await healToolNodejsWithAI(
+            workspaceRoot, flowName, uuid, instanceId, resolvedScript,
+            errorInfo, healOptions.cli, healOptions.model,
+          );
+        }
+
+        if (TOOL_NODEJS_RETRY_DELAY_MS > 0) {
+          spawnSync("sleep", [String(TOOL_NODEJS_RETRY_DELAY_MS / 1000)], { stdio: "ignore" });
+        }
+      }
+    }
+  }
+  throw lastError;
+}
+
+function persistToolNodejsStderr(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 executeToolNodejsOnce(workspaceRoot, flowName, uuid, instanceId, resolvedScript, execId) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const outputDir = path.join(runDir, outputDirForNode(instanceId));
+
+  const { argv, commandLine: normalized } = nodeToolCommandToArgv(resolvedScript);
+  let child;
+  if (/^node\s/i.test(String(normalized).trim()) && argv.length >= 1) {
+    child = spawnSync(process.execPath, argv, {
+      cwd: workspaceRoot,
+      shell: false,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+  } else {
+    child = spawnSync(normalized, [], {
+      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;
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  // 直接写文件模式：stdout 为空 + exit 0 → 脚本已自行写入 output 文件，无需解析
+  if (!stdout.trim() && exitCode === 0) {
+    persistToolNodejsStderr(outputDir, instanceId, execId, stderr);
+    writeResult(workspaceRoot, flowName, uuid, instanceId,
+      { status: "success", message: "执行完成" },
+      { preserveBody: true, execId });
+    return;
+  }
+
+  // 非零退出码 + 无 stdout → 直接失败
+  if (!stdout.trim() && exitCode !== 0) {
+    const baseDetail = `脚本退出码 ${exitCode}` + (stderr.trim() ? `：${stderr.trim().slice(0, 200)}` : "");
+    const detail = baseDetail + buildPipelineScriptPathHint(stderr);
+    persistToolNodejsStderr(outputDir, instanceId, execId, stderr);
+    writeResult(workspaceRoot, flowName, uuid, instanceId,
+      { status: "failed", message: detail },
+      { preserveBody: true, execId });
+    const err = new Error(`Script failed: ${detail}`);
+    err.scriptStdout = stdout;
+    err.scriptStderr = stderr;
+    err.scriptExitCode = exitCode;
+    throw err;
+  }
+
+  // JSON stdout 模式（兼容旧脚本）
+  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);
+    persistToolNodejsStderr(outputDir, instanceId, execId, stderr);
+    writeResult(workspaceRoot, flowName, uuid, instanceId,
+      { status: "failed", message: detail },
+      { preserveBody: true, execId });
+    const err = new Error(`Script failed: ${detail}`);
+    err.scriptStdout = stdout;
+    err.scriptStderr = stderr;
+    err.scriptExitCode = exitCode;
+    throw err;
+  }
+
+  const isSynthetic = Boolean(payload._synthetic);
+  const success = isSynthetic ? exitCode === 0 : payload.err_code === 0;
+  const message = payload.message;
+  // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理，此处只写新 output。
+  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",
+    );
+  }
+  persistToolNodejsStderr(outputDir, instanceId, execId, stderr);
+
+  writeResult(workspaceRoot, flowName, uuid, instanceId,
+    { status: success ? "success" : "failed",
+      message: success ? "执行完成" : "执行未通过" },
+    { preserveBody: true, execId });
+
+  if (!success) {
+    const hint = stderr.trim() ? ` ${stderr.trim().slice(0, 280)}` : "";
+    const err = new Error(`Script failed (exit ${exitCode}): ${String(normalized).slice(0, 120)}${hint}`);
+    err.scriptStdout = stdout;
+    err.scriptStderr = stderr;
+    err.scriptExitCode = exitCode;
+    throw err;
+  }
+}
+
+/**
+ * Execute one node: 按 definitionId / resolvedScript / directCommand 决定执行方式。
+ */
+export async function executeNode(workspaceRoot, flowName, uuid, instanceId, preOutput, options = {}) {
+  const { definitionId, directCommand, resolvedScript, promptPath, nodeContext, taskBody, resultPath, subagent } = preOutput;
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const intermediatePath = runDir;
+
+  if (definitionId && LOCAL_ONLY_DEFINITION_IDS.has(definitionId)) {
+    return;
+  }
+
+  if (resolvedScript) {
+    const execId = preOutput.execId ?? 1;
+    let healOptions = null;
+    if (AI_HEAL_ENABLED) {
+      const { cli, model } = resolveCliAndModel(workspaceRoot, preOutput.model ?? null, options.model ?? null);
+      healOptions = {
+        cli: cli === "api" ? "cursor" : cli,
+        model,
+      };
+    }
+    emitEvent(workspaceRoot, flowName, uuid, {
+      event: "direct-command-start",
+      instanceId,
+      directCommand: resolvedScript,
+    });
+    try {
+      await executeToolNodejsInline(workspaceRoot, flowName, uuid, instanceId, resolvedScript, execId, healOptions);
+      emitEvent(workspaceRoot, flowName, uuid, {
+        event: "direct-command-done",
+        instanceId,
+        directCommand: resolvedScript,
+      });
+    } catch (err) {
+      emitEvent(workspaceRoot, flowName, uuid, {
+        event: "direct-command-failed",
+        instanceId,
+        directCommand: resolvedScript,
+        error: err.message,
+      });
+      throw err;
+    }
+    return;
+  }
+
+  if (directCommand) {
+    emitEvent(workspaceRoot, flowName, uuid, {
+      event: "direct-command-start",
+      instanceId,
+      directCommand,
+    });
+    try {
+      const result = spawnSync(directCommand, [], { cwd: workspaceRoot, shell: true, stdio: "inherit" });
+      if (result.status !== 0) {
+        emitEvent(workspaceRoot, flowName, uuid, {
+          event: "direct-command-failed",
+          instanceId,
+          directCommand,
+          exitCode: result.status,
+        });
+        throw new Error(`Direct command failed: ${directCommand}`);
+      }
+      emitEvent(workspaceRoot, flowName, uuid, {
+        event: "direct-command-done",
+        instanceId,
+        directCommand,
+      });
+    } catch (err) {
+      if (err.message && !err.message.includes("Direct command failed")) {
+        emitEvent(workspaceRoot, flowName, uuid, {
+          event: "direct-command-failed",
+          instanceId,
+          directCommand,
+          error: err.message,
+        });
+      }
+      throw err;
+    }
+    return;
+  }
+
+  const { cli, model } = resolveCliAndModel(workspaceRoot, preOutput.model ?? null, options.model ?? null);
+
+  const execId = preOutput.execId ?? 1;
+  // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理，此处直接进入 agent 执行。
+
+  emitEvent(workspaceRoot, flowName, uuid, {
+    event: "agent-invoke-start",
+    instanceId,
+    subagent: subagent ?? null,
+    promptPath: promptPath ?? null,
+    resultPathRel: resultPath ?? null,
+    modelCli: cli,
+    model: model ?? null,
+  });
+  try {
+    if (cli === "api") {
+      await runApiAgentForNode(
+        workspaceRoot,
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", subagent, instanceId },
+        {
+          model,
+          onToolCall: options.onToolCall,
+          flowName,
+          uuid,
+        },
+      );
+    } else if (cli === "opencode") {
+      await runOpenCodeAgentForNode(
+        workspaceRoot,
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
+        {
+          model,
+          stderrBuffer: options.stderrBuffer,
+          force: options.force,
+          outputPrefix: options.outputPrefix,
+          prefixColor: options.prefixColor,
+          onToolCall: options.onToolCall,
+          flowName,
+          uuid,
+        },
+      );
+    } else if (cli === "claude-code") {
+      await runClaudeCodeAgentForNode(
+        workspaceRoot,
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
+        {
+          model,
+          stderrBuffer: options.stderrBuffer,
+          force: options.force,
+          outputPrefix: options.outputPrefix,
+          prefixColor: options.prefixColor,
+          onToolCall: options.onToolCall,
+          flowName,
+          uuid,
+        },
+      );
+    } else {
+      await runCursorAgentForNode(
+        workspaceRoot,
+        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
+        {
+          model,
+          stderrBuffer: options.stderrBuffer,
+          force: options.force,
+          outputPrefix: options.outputPrefix,
+          prefixColor: options.prefixColor,
+          onToolCall: options.onToolCall,
+          flowName,
+          uuid,
+        },
+      );
+    }
+    emitEvent(workspaceRoot, flowName, uuid, {
+      event: "agent-invoke-done",
+      instanceId,
+      subagent: subagent ?? null,
+      modelCli: cli,
+      model: model ?? null,
+    });
+  } catch (err) {
+    const payload = {
+      event: "agent-invoke-failed",
+      instanceId,
+      subagent: subagent ?? null,
+      modelCli: cli,
+      model: model ?? null,
+      error: err && err.message ? String(err.message) : String(err),
+    };
+    if (err && err.cursorStderrTail) payload.cursorStderrTail = err.cursorStderrTail;
+    emitEvent(workspaceRoot, flowName, uuid, payload);
+    throw err;
+  }
+}
+
+/**
+ * @param {number | undefined} [opts.elapsedMs] 本节点执行耗时（毫秒），写入 result.elapsedMs 供 UI 展示
+ */
+export function runPostProcess(workspaceRoot, flowName, uuid, instanceId, execId, opts = {}) {
+  const args = [workspaceRoot, flowName, uuid, instanceId, String(execId)];
+  const { elapsedMs } = opts;
+  if (elapsedMs != null && Number.isFinite(elapsedMs) && elapsedMs >= 0) {
+    args.push(String(Math.round(elapsedMs)));
+  }
+  const result = runNodeScript(workspaceRoot, "post-process-node.mjs", args, {
+    captureStdout: true,
+  });
+  parseJsonStdout(result);
+}
+
+export function ensureLocalNodeTerminalSuccess(workspaceRoot, flowName, uuid, instanceId, preOutput) {
+  if (!preOutput.definitionId || !LOCAL_ONLY_TERMINAL_SUCCESS_IDS.has(preOutput.definitionId)) return;
+  const payload = {
+    status: "success",
+    message: "已通过",
+    execId: preOutput.execId ?? 1,
+  };
+  const result = runNodeScript(
+    workspaceRoot,
+    "write-result.mjs",
+    [workspaceRoot, flowName, uuid, instanceId, "--json", JSON.stringify(payload)],
+    { captureStdout: true },
+  );
+  if (result.status !== 0) {
+    log.warn(`[agentflow] ensureLocalNodeTerminalSuccess write-result failed for ${instanceId}: ${result.stdout || result.stderr || result.status}`);
+  }
+}

package/bin/lib/normalize-node-tool-command.mjs

@@ -0,0 +1,97 @@
+/**
+ * 规范化 tool_nodejs 的 script 命令行，修复误写 `node "${workspaceRoot}/..."` 等导致的错误路径。
+ * 供 node-execute（内联执行）与 run-tool-nodejs（子进程）共用。
+ */
+
+/**
+ * 合并 bash 风格「'片段'/后续路径」拼接，得到真实文件系统路径。
+ * 同时处理中间嵌入的 `/'T'/` 形态（脚本模板里对变量加单引号，
+ * 但这些单引号对 spawn/非 shell 调用是字面量，需剥掉）。
+ */
+export function normalizeConcatenatedSingleQuotedPath(s) {
+  let out = String(s).trim();
+  for (let n = 0; n < 64; n++) {
+    // 开头：'x'/y 或 'x'.y → xy
+    let next = out.replace(/^'([^']*)'(\/|\.)/, "$1$2");
+    // 中间：/'x'/ 或 /'x'. → /x/ 或 /x.  （保留前后分隔符，避免误吃尾随空格后的独立 '…' 参数）
+    next = next.replace(/(\/)'([^'\s]*)'(\/|\.)/g, "$1$2$3");
+    if (next === out) break;
+    out = next;
+  }
+  return out;
+}
+
+/**
+ * 去掉首段外层双引号（含 `node "'/a'/.b" --flags`：首段结束后还有参数）。
+ */
+export function stripOuterDoubleQuotes(rest) {
+  const t = rest.trim();
+  if (!t.startsWith('"')) return t;
+  for (let i = 1; i < t.length; i++) {
+    if (t[i] === '"' && (i + 1 >= t.length || /\s/.test(t[i + 1]))) {
+      return (t.slice(1, i) + t.slice(i + 1)).trim();
+    }
+  }
+  if (t.endsWith('"')) return t.slice(1, -1).trim();
+  return t.slice(1).trim();
+}
+
+/**
+ * 极简 shell 式分词：未加引号片段、单引号块、双引号块。
+ */
+export function parseShellLikeArgs(input) {
+  const args = [];
+  const str = String(input);
+  let i = 0;
+  const len = str.length;
+  while (i < len) {
+    while (i < len && /\s/.test(str[i])) i++;
+    if (i >= len) break;
+    let arg = "";
+    if (str[i] === "'") {
+      i++;
+      while (i < len && str[i] !== "'") arg += str[i++];
+      if (str[i] === "'") i++;
+    } else if (str[i] === '"') {
+      i++;
+      while (i < len && str[i] !== '"') {
+        if (str[i] === "\\" && i + 1 < len) arg += str[++i];
+        else arg += str[i];
+        i++;
+      }
+      if (str[i] === '"') i++;
+    } else {
+      while (i < len && !/\s/.test(str[i])) arg += str[i++];
+    }
+    args.push(arg);
+  }
+  return args;
+}
+
+/**
+ * @param {string} resolvedScript - 如 node "'/root'/.workspace/.../x.mjs" 或 node "${workspaceRoot}/..." 解析后的错误形态
+ * @returns {string}
+ */
+export function normalizeNodeToolCommandLine(resolvedScript) {
+  const t = String(resolvedScript).trim();
+  const m = t.match(/^node\s+/i);
+  if (!m) return resolvedScript;
+  let rest = t.slice(m[0].length).trim();
+  rest = stripOuterDoubleQuotes(rest);
+  rest = normalizeConcatenatedSingleQuotedPath(rest);
+  return `node ${rest}`;
+}
+
+/**
+ * @returns {{ argv: string[], commandLine: string }}
+ */
+export function nodeToolCommandToArgv(commandLine) {
+  const normalized = normalizeNodeToolCommandLine(commandLine);
+  const nodeLead = normalized.match(/^node\s+/i);
+  if (!nodeLead) {
+    return { argv: [], commandLine: normalized };
+  }
+  const rest = normalized.slice(nodeLead[0].length).trim();
+  const argv = parseShellLikeArgs(rest);
+  return { argv, commandLine: normalized };
+}