@fieldwangai/agentflow 0.1.25

package/bin/lib/model-config.mjs

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path from "path";
+
+import { LEGACY_MODEL_CONFIG_REL, MODEL_CONFIG_REL } from "./paths.mjs";
+
+const modelConfigCache = new Map();
+
+/** UI 格式为「模型 ID - 描述」，传参只用前面的模型 ID。若为 "auto" 则规范为 Cursor 可识别的 "Auto"。 */
+export function normalizeCursorModelForCli(value) {
+  if (value == null || value === false || value === "") return "Auto";
+  let s = String(value).trim();
+  if (!s) return "Auto";
+  const dashIdx = s.indexOf(" - ");
+  if (dashIdx >= 0) s = s.slice(0, dashIdx).trim();
+  if (!s) return "Auto";
+  if (/^auto$/i.test(s)) return "Auto";
+  return s;
+}
+
+export function loadModelConfig(workspaceRoot) {
+  const root = path.resolve(workspaceRoot);
+  if (modelConfigCache.has(root)) return modelConfigCache.get(root);
+  const primaryPath = path.join(root, MODEL_CONFIG_REL);
+  const legacyPath = path.join(root, LEGACY_MODEL_CONFIG_REL);
+  const configPath = fs.existsSync(primaryPath) ? primaryPath : legacyPath;
+  let config = { models: {} };
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = fs.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && parsed.models && typeof parsed.models === "object") {
+        config = { models: parsed.models };
+      }
+    }
+  } catch (_) {
+    // ignore parse errors
+  }
+  modelConfigCache.set(root, config);
+  return config;
+}
+
+export function resolveCliAndModel(workspaceRoot, nodeModel, agentModelOverride) {
+  if (agentModelOverride && String(agentModelOverride).trim()) {
+    const raw = String(agentModelOverride).trim();
+    if (raw.startsWith("api:")) {
+      return { cli: "api", model: raw, label: raw };
+    }
+    if (raw.startsWith("claude-code:")) {
+      const m = raw.slice("claude-code:".length).trim();
+      return {
+        cli: "claude-code",
+        model: m || null,
+        label: m ? `claude-code: ${m}` : "claude-code (default)",
+      };
+    }
+    if (raw.startsWith("opencode:")) {
+      const m = raw.slice("opencode:".length).trim();
+      return {
+        cli: "opencode",
+        model: m || null,
+        label: m ? `opencode: ${m}` : "opencode (default)",
+      };
+    }
+    const model = normalizeCursorModelForCli(raw);
+    return { cli: "cursor", model, label: `cursor: ${model}` };
+  }
+
+  const key = nodeModel && String(nodeModel).trim() ? String(nodeModel).trim() : "";
+  if (key) {
+    const { models } = loadModelConfig(workspaceRoot);
+    const cfg = models[key];
+    if (cfg && typeof cfg === "object" && cfg.cli && cfg.model) {
+      const cli =
+        cfg.cli === "opencode"
+          ? "opencode"
+          : cfg.cli === "api"
+            ? "api"
+            : cfg.cli === "claude-code"
+              ? "claude-code"
+              : "cursor";
+      const model = String(cfg.model).trim();
+      return { cli, model, label: `${cli}: ${model}` };
+    }
+  }
+
+  if (key && key.startsWith("api:")) {
+    return { cli: "api", model: key, label: key };
+  }
+
+  if (key && key.startsWith("claude-code:")) {
+    const model = key.slice("claude-code:".length) || "";
+    return {
+      cli: "claude-code",
+      model: model || null,
+      label: model ? `claude-code: ${model}` : "claude-code (default)",
+    };
+  }
+
+  if (key && key.startsWith("opencode:")) {
+    const model = key.slice("opencode:".length) || "";
+    return {
+      cli: "opencode",
+      model: model || null,
+      label: model ? `opencode: ${model}` : "opencode (default)",
+    };
+  }
+
+  const envModel = process.env.CURSOR_AGENT_MODEL && String(process.env.CURSOR_AGENT_MODEL).trim();
+  if (envModel && envModel.startsWith("api:")) {
+    return { cli: "api", model: envModel, label: envModel };
+  }
+  const model = normalizeCursorModelForCli(key || envModel || "Auto");
+  return {
+    cli: "cursor",
+    model,
+    label: model === "Auto" ? "cursor: Auto" : `cursor: ${model}`,
+  };
+}

package/bin/lib/model-lists.mjs

@@ -0,0 +1,188 @@
+import { spawn } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { CURSOR_NON_MODEL_PATTERNS, getAgentflowUserConfigAbs, getModelListsAbs } from "./paths.mjs";
+
+/** GUI / 精简 PATH 下常见找不到 Homebrew 等目录下的 CLI，为子进程补上 */
+function envWithCommonBinPaths() {
+  const env = { ...process.env };
+  const extra = [
+    path.join(os.homedir(), ".local", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+  ].filter((p) => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  });
+  if (extra.length === 0) return env;
+  const sep = path.delimiter;
+  const prefix = extra.join(sep);
+  env.PATH = env.PATH && String(env.PATH).trim() !== "" ? `${prefix}${sep}${env.PATH}` : prefix;
+  return env;
+}
+
+export function stripAnsiModelList(text) {
+  return String(text || "").replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+
+export function isCursorModelLine(line) {
+  const lower = line.toLowerCase();
+  if (lower.startsWith("name") || lower === "models" || lower === "model") return false;
+  if (lower.startsWith("error") || lower.startsWith("fatal") || lower.startsWith("warning:")) return false;
+  if (CURSOR_NON_MODEL_PATTERNS.some((re) => re.test(line))) return false;
+  return line.length > 0 && line.length < 200;
+}
+
+export function parseModelLines(stdout) {
+  const cleaned = stripAnsiModelList(stdout);
+  const lines = cleaned.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  return lines.filter(isCursorModelLine);
+}
+
+export function runCursorModels(workspaceRoot) {
+  return new Promise((resolve) => {
+    const agentCmd = process.env.CURSOR_AGENT_CMD || "agent";
+    const child = spawn(agentCmd, ["models"], { cwd: workspaceRoot, shell: false });
+    let out = "";
+    child.stdout?.on("data", (chunk) => {
+      out += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      out += chunk.toString("utf-8");
+    });
+    child.on("close", (code) => (code === 0 ? resolve(parseModelLines(out)) : resolve([])));
+    child.on("error", () => resolve([]));
+  });
+}
+
+/**
+ * Claude Code CLI 不暴露模型列表子命令 — 使用内置列表。
+ * 新模型发布时更新此常量即可。
+ */
+export const BUILTIN_CLAUDE_CODE_MODELS = [
+  "claude-opus-4-7",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+];
+
+export function getBuiltinClaudeCodeModels() {
+  return BUILTIN_CLAUDE_CODE_MODELS.slice();
+}
+
+/**
+ * 探测 Claude Code CLI 是否可用（仅判定能否启动，不拉取模型）。
+ */
+export function probeClaudeCodeAvailable() {
+  return new Promise((resolve) => {
+    const claudeCmd = process.env.CLAUDE_CODE_CMD || "claude";
+    const child = spawn(claudeCmd, ["--version"], {
+      shell: false,
+      env: envWithCommonBinPaths(),
+    });
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve(ok);
+    };
+    child.on("close", (code) => finish(code === 0));
+    child.on("error", () => finish(false));
+    setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      finish(false);
+    }, 5000);
+  });
+}
+
+export function runOpencodeModels(workspaceRoot, provider) {
+  if (!provider || !String(provider).trim()) return Promise.resolve([]);
+  return new Promise((resolve) => {
+    const opencodeCmd = process.env.OPENCODE_CMD || "opencode";
+    const child = spawn(opencodeCmd, ["models", String(provider).trim()], {
+      cwd: workspaceRoot,
+      shell: false,
+      env: envWithCommonBinPaths(),
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf-8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve(parseModelLines(stdout || stderr));
+      else resolve([]);
+    });
+    child.on("error", () => resolve([]));
+  });
+}
+
+/**
+ * 拉取 Cursor / OpenCode 模型列表并写入 ~/agentflow/model-lists.json
+ * @param {string} workspaceRoot
+ * @param {{ opencodeProviderOverride?: string }} [opts]
+ */
+export async function updateModelLists(workspaceRoot, opts = {}) {
+  const root = path.resolve(workspaceRoot);
+  const override =
+    typeof opts.opencodeProviderOverride === "string" ? opts.opencodeProviderOverride.trim() : "";
+  let opencodeProvider = override;
+  if (!opencodeProvider) {
+    try {
+      const configPath = getAgentflowUserConfigAbs();
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (typeof config?.opencodeProvider === "string") opencodeProvider = config.opencodeProvider.trim();
+      }
+    } catch (_) {}
+  }
+
+  const cachePath = getModelListsAbs();
+  let prev = {
+    cursor: [],
+    opencode: [],
+    claudeCode: [],
+    cursorFetchedAt: null,
+    opencodeFetchedAt: null,
+    claudeCodeFetchedAt: null,
+  };
+  try {
+    if (fs.existsSync(cachePath)) {
+      const raw = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) prev = { ...prev, ...raw };
+    }
+  } catch (_) {}
+
+  const [cursorRaw, opencode, claudeCodeAvailable] = await Promise.all([
+    runCursorModels(root),
+    runOpencodeModels(root, opencodeProvider),
+    probeClaudeCodeAvailable(),
+  ]);
+  const cursor = cursorRaw.filter(isCursorModelLine);
+  const claudeCode = claudeCodeAvailable ? getBuiltinClaudeCodeModels() : [];
+  const now = Date.now();
+
+  const data = {
+    cursor: cursor.length > 0 ? cursor : prev.cursor ?? [],
+    opencode: opencode.length > 0 ? opencode : prev.opencode ?? [],
+    claudeCode: claudeCode.length > 0 ? claudeCode : prev.claudeCode ?? [],
+    cursorFetchedAt: cursor.length > 0 ? now : prev.cursorFetchedAt ?? null,
+    opencodeFetchedAt: opencode.length > 0 ? now : prev.opencodeFetchedAt ?? null,
+    claudeCodeFetchedAt: claudeCode.length > 0 ? now : prev.claudeCodeFetchedAt ?? null,
+  };
+
+  try {
+    fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (_) {}
+
+  return { cursor: data.cursor, opencode: data.opencode, claudeCode: data.claudeCode };
+}

package/bin/lib/node-exec-context.mjs

@@ -0,0 +1,336 @@
+/**
+ * Reads intermediate + output files for a given node instance across all execution rounds.
+ * Used by the UI run-mode sidebar to show prompt, result, and output content per execId.
+ */
+import fs from "fs";
+import path from "path";
+import { getWorkspaceRunBuildRoot } from "./paths.mjs";
+
+/**
+ * @param {string} workspaceRoot
+ * @param {string} flowId
+ * @param {string} instanceId
+ * @param {string} [runId] - specific uuid; if empty, picks the latest run
+ * @returns {{ ok: boolean, rounds: Array, runId?: string, error?: string }}
+ */
+export function getNodeExecContext(workspaceRoot, flowId, instanceId, runId) {
+  const runBuildRoot = getWorkspaceRunBuildRoot(workspaceRoot);
+  const flowRunDir = path.join(runBuildRoot, flowId);
+  if (!fs.existsSync(flowRunDir)) return { ok: true, rounds: [], runId: "" };
+
+  let uuid = runId;
+  if (!uuid) {
+    const entries = fs.readdirSync(flowRunDir).filter((e) => {
+      const s = fs.statSync(path.join(flowRunDir, e));
+      return s.isDirectory();
+    });
+    entries.sort((a, b) => b.localeCompare(a));
+    uuid = entries[0] || "";
+  }
+  if (!uuid) return { ok: true, rounds: [], runId: "" };
+
+  const runDir = path.join(flowRunDir, uuid);
+  const interDir = path.join(runDir, "intermediate", instanceId);
+  const outDir = path.join(runDir, "output", instanceId);
+
+  const rounds = collectRounds(interDir, outDir, instanceId);
+
+  return { ok: true, rounds, runId: uuid };
+}
+
+function collectRounds(interDir, outDir, instanceId) {
+  const roundMap = new Map();
+  const currentBasename = `${instanceId}.result.md`;
+
+  if (fs.existsSync(interDir)) {
+    const files = fs.readdirSync(interDir);
+    for (const f of files) {
+      const fp = path.join(interDir, f);
+      if (!fs.statSync(fp).isFile()) continue;
+
+      if (f === currentBasename) {
+        ensureRound(roundMap, "current");
+        roundMap.get("current").resultFile = fp;
+        continue;
+      }
+
+      const promptCurrentName = `${instanceId}.prompt.md`;
+      if (f === promptCurrentName) {
+        ensureRound(roundMap, "current");
+        roundMap.get("current").promptFile = fp;
+        continue;
+      }
+
+      const cacheCurrentName = `${instanceId}.cache.json`;
+      if (f === cacheCurrentName) {
+        ensureRound(roundMap, "current");
+        roundMap.get("current").cacheFile = fp;
+        continue;
+      }
+
+      const backupResult = f.match(new RegExp(`^${escRe(instanceId)}\\.result_(\\d+)\\.md$`));
+      if (backupResult) {
+        const eid = backupResult[1];
+        ensureRound(roundMap, eid);
+        roundMap.get(eid).resultFile = fp;
+        continue;
+      }
+
+      const backupPrompt = f.match(new RegExp(`^${escRe(instanceId)}\\.prompt_(\\d+)\\.md$`));
+      if (backupPrompt) {
+        const eid = backupPrompt[1];
+        ensureRound(roundMap, eid);
+        roundMap.get(eid).promptFile = fp;
+        continue;
+      }
+    }
+  }
+
+  if (fs.existsSync(outDir)) {
+    const files = fs.readdirSync(outDir);
+    const prefix = `node_${instanceId}_`;
+    for (const f of files) {
+      const fp = path.join(outDir, f);
+      if (!fs.statSync(fp).isFile()) continue;
+      if (!f.startsWith(prefix)) continue;
+
+      const backupOut = f.match(
+        new RegExp(`^${escRe(prefix)}(.+?)_(\\d+)(\\.[a-zA-Z0-9]+)$`),
+      );
+      if (backupOut) {
+        const slot = backupOut[1];
+        const eid = backupOut[2];
+        ensureRound(roundMap, eid);
+        const r = roundMap.get(eid);
+        if (!r.outputFiles) r.outputFiles = [];
+        r.outputFiles.push({ slot, path: fp });
+        continue;
+      }
+
+      const currentOut = f.match(new RegExp(`^${escRe(prefix)}(.+)(\\.[a-zA-Z0-9]+)$`));
+      if (currentOut) {
+        const slot = currentOut[1];
+        ensureRound(roundMap, "current");
+        const r = roundMap.get("current");
+        if (!r.outputFiles) r.outputFiles = [];
+        r.outputFiles.push({ slot, path: fp });
+      }
+    }
+  }
+
+  const result = [];
+  for (const [key, data] of roundMap) {
+    // Skip phantom rounds that only have a prompt backup but no result/cache/output
+    // (caused by prior buildNodePrompt double-call bug creating spurious _N backups)
+    if (key !== "current" && !data.resultFile && !data.cacheFile && !data.outputFiles) continue;
+
+    const round = { execId: key === "current" ? "latest" : key };
+
+    if (data.resultFile) {
+      const raw = safeRead(data.resultFile);
+      const fm = parseResultFrontmatter(raw);
+      round.status = fm.status || null;
+      round.finishedAt = fm.finishedAt || null;
+      round.message = fm.message || null;
+    }
+
+    if (data.cacheFile) {
+      try {
+        const cacheRaw = safeRead(data.cacheFile, 200000);
+        const cacheJson = JSON.parse(cacheRaw);
+        if (cacheJson.cacheInputInfo) {
+          const inputInfo = typeof cacheJson.cacheInputInfo === "string"
+            ? JSON.parse(cacheJson.cacheInputInfo)
+            : cacheJson.cacheInputInfo;
+          if (Array.isArray(inputInfo.inputPaths)) {
+            round.inputs = inputInfo.inputPaths
+              .filter((p) => p.slot !== "upstreamMd5")
+              .map((p) => ({ slot: p.slot, value: p.value ?? "" }));
+          }
+        }
+      } catch {
+        /* ignore parse errors */
+      }
+    }
+
+    if (data.promptFile) {
+      round.prompt = safeRead(data.promptFile, 50000);
+    }
+
+    if (data.outputFiles && data.outputFiles.length > 0) {
+      round.outputs = data.outputFiles.map((o) => readOutputForUi(o.path, o.slot));
+    }
+
+    result.push(round);
+  }
+
+  result.sort((a, b) => {
+    if (a.execId === "latest") return 1;
+    if (b.execId === "latest") return -1;
+    return Number(a.execId) - Number(b.execId);
+  });
+
+  return result;
+}
+
+function ensureRound(map, key) {
+  if (!map.has(key)) map.set(key, {});
+}
+
+function escRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+const TEXT_MAX = 50000;
+const BINARY_MAX = 5 * 1024 * 1024;
+
+function safeRead(fp, maxLen) {
+  try {
+    const cap = maxLen != null && maxLen > 0 ? maxLen : TEXT_MAX;
+    const st = fs.statSync(fp);
+    if (st.size > cap) {
+      const fd = fs.openSync(fp, "r");
+      try {
+        const buf = Buffer.alloc(Math.min(cap + 4, st.size));
+        fs.readSync(fd, buf, 0, buf.length, 0);
+        return buf.toString("utf-8").slice(0, cap) + "\n…(truncated)";
+      } finally {
+        fs.closeSync(fd);
+      }
+    }
+    let content = fs.readFileSync(fp, "utf-8");
+    if (content.length > cap) content = content.slice(0, cap) + "\n…(truncated)";
+    return content;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Sniff binary image / common formats from the first bytes (handles e.g. PNG written under a .md path).
+ * @param {Buffer} buf
+ * @returns {{ mime: string, displayKind: string } | null}
+ */
+function sniffBinaryKind(buf) {
+  if (!buf || buf.length < 4) return null;
+  if (buf.length >= 8 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
+    return { mime: "image/png", displayKind: "image" };
+  }
+  if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+    return { mime: "image/jpeg", displayKind: "image" };
+  }
+  if (buf.length >= 6 && buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x38) {
+    return { mime: "image/gif", displayKind: "image" };
+  }
+  if (buf.length >= 12 && buf.toString("ascii", 0, 4) === "RIFF" && buf.toString("ascii", 8, 12) === "WEBP") {
+    return { mime: "image/webp", displayKind: "image" };
+  }
+  if (buf.length >= 2 && buf.toString("ascii", 0, 2) === "BM") {
+    return { mime: "image/bmp", displayKind: "image" };
+  }
+  return null;
+}
+
+function extMime(ext) {
+  const e = (ext || "").toLowerCase();
+  const map = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".markdown": "text/markdown",
+  };
+  return map[e] || null;
+}
+
+function isLikelyJsonText(s) {
+  const t = (s || "").trim();
+  if (!t || (t[0] !== "{" && t[0] !== "[")) return false;
+  try {
+    JSON.parse(t);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {string} fp
+ * @param {string} slot
+ * @returns {{ slot: string, content: string, encoding: string, mimeType?: string, displayKind: string }}
+ */
+function readOutputForUi(fp, slot) {
+  try {
+    const st = fs.statSync(fp);
+    const ext = path.extname(fp);
+    const readSize = Math.min(st.size, BINARY_MAX);
+    const buf = Buffer.alloc(readSize);
+    const fd = fs.openSync(fp, "r");
+    try {
+      fs.readSync(fd, buf, 0, readSize, 0);
+    } finally {
+      fs.closeSync(fd);
+    }
+
+    const sniffed = sniffBinaryKind(buf);
+    if (sniffed) {
+      const truncated = st.size > BINARY_MAX;
+      return {
+        slot,
+        content: buf.toString("base64"),
+        encoding: "base64",
+        mimeType: sniffed.mime,
+        displayKind: sniffed.displayKind,
+        ...(truncated ? { truncated: true } : {}),
+      };
+    }
+
+    let text = buf.toString("utf8");
+    const cap = TEXT_MAX;
+    let truncatedText = false;
+    if (text.length > cap) {
+      text = text.slice(0, cap);
+      truncatedText = true;
+    } else if (st.size > readSize) {
+      truncatedText = true;
+    }
+
+    const mimeFromExt = extMime(ext);
+    let displayKind = "text";
+    if (mimeFromExt === "application/json" || isLikelyJsonText(text)) {
+      displayKind = "json";
+    } else if (mimeFromExt === "text/markdown" || ext === ".md" || ext === ".markdown") {
+      displayKind = "markdown";
+    }
+
+    const out = {
+      slot,
+      content: truncatedText ? text + "\n…(truncated)" : text,
+      encoding: "utf-8",
+      displayKind,
+    };
+    if (mimeFromExt) out.mimeType = mimeFromExt;
+    return out;
+  } catch {
+    return { slot, content: "", encoding: "utf-8", displayKind: "text" };
+  }
+}
+
+function parseResultFrontmatter(raw) {
+  const m = raw.match(/^---\s*\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  const obj = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const idx = line.indexOf(": ");
+    if (idx <= 0) continue;
+    const k = line.slice(0, idx).trim();
+    let v = line.slice(idx + 2).trim();
+    if (v.startsWith('"') && v.endsWith('"')) v = v.slice(1, -1).replace(/\\n/g, "\n").replace(/\\"/g, '"');
+    obj[k] = v;
+  }
+  return obj;
+}