@fieldwangai/agentflow 0.1.153 → 0.1.154

package/bin/lib/node-execute.mjs

@@ -1,539 +0,0 @@
-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 {
-  runCodexAgentForNode,
-  runCodexAgentWithPrompt,
-  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 === "codex" ? "codex" : 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 === "codex") {
-      const { finished } = runCodexAgentWithPrompt(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, execWorkspaceRoot = workspaceRoot) {
-  let lastError;
-  for (let attempt = 1; attempt <= TOOL_NODEJS_MAX_RETRIES + 1; attempt++) {
-    try {
-      executeToolNodejsOnce(workspaceRoot, flowName, uuid, instanceId, resolvedScript, execId, execWorkspaceRoot);
-      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, execWorkspaceRoot = workspaceRoot) {
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
-  const outputDir = path.join(runDir, outputDirForNode(instanceId));
-  fs.mkdirSync(outputDir, { recursive: true });
-
-  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: execWorkspaceRoot,
-      shell: false,
-      stdio: ["inherit", "pipe", "pipe"],
-    });
-  } else {
-    child = spawnSync(normalized, [], {
-      cwd: execWorkspaceRoot,
-      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;
-
-  // 直接写文件模式：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;
-  const execWorkspaceRoot = path.resolve(preOutput.workspaceContext?.workspaceRoot || preOutput.workspaceContext?.cwd || workspaceRoot);
-
-  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, execWorkspaceRoot);
-      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: execWorkspaceRoot, 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,
-    execWorkspaceRoot,
-  });
-  try {
-    if (cli === "api") {
-      await runApiAgentForNode(
-        workspaceRoot,
-        { promptPath, nodeContext: nodeContext ?? "", taskBody: taskBody ?? "", intermediatePath, resultPathRel: resultPath, subagent, instanceId },
-        {
-          model,
-          onToolCall: options.onToolCall,
-          flowName,
-          uuid,
-          execWorkspaceRoot,
-        },
-      );
-    } 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,
-          execWorkspaceRoot,
-        },
-      );
-    } else if (cli === "codex") {
-      await runCodexAgentForNode(
-        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,
-          execWorkspaceRoot,
-        },
-      );
-    } 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,
-          execWorkspaceRoot,
-        },
-      );
-    } 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,
-          execWorkspaceRoot,
-        },
-      );
-    }
-    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

@@ -1,97 +0,0 @@
-/**
- * 规范化 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 };
-}