@fieldwangai/agentflow 0.1.87 → 0.1.88

package/bin/lib/agent-runners.mjs

@@ -10,6 +10,14 @@ import { appendRunLogLine } from "./run-events.mjs";
 import { writeWithPrefix } from "./terminal.mjs";
 import { t } from "./i18n.mjs";
 import { readMergedEnvObject } from "./user-env.mjs";
+import {
+  createCursorApiKeyAttempts,
+  cursorApiKeyCooldownMinutes,
+  cursorApiKeyEnv,
+  cursorApiKeyLabel,
+  isCursorQuotaError,
+  markCursorApiKeyQuotaBlocked,
+} from "./cursor-api-key-pool.mjs";
 import { outputNodeBasename } from "../pipeline/get-exec-id.mjs";
 
 function shouldPassCursorModelArg(model) {
@@ -23,6 +31,45 @@ function childEnv(options = {}, extra = {}) {
   return { ...process.env, ...readMergedEnvObject(userId), ...optEnv, ...extra };
 }
 
+function cursorAttemptOptions(options = {}) {
+  const baseEnv = childEnv(options);
+  const attempts = Array.isArray(options._agentflowCursorApiKeyAttempts)
+    ? options._agentflowCursorApiKeyAttempts
+    : createCursorApiKeyAttempts(baseEnv);
+  const attemptIndex = Math.max(0, Number(options._agentflowCursorApiKeyAttemptIndex || 0) || 0);
+  const selection = attempts[attemptIndex];
+  return { baseEnv, attempts, attemptIndex, selection };
+}
+
+function nextCursorAttemptOptions(options = {}, attempts = [], attemptIndex = 0) {
+  return {
+    ...options,
+    _agentflowCursorApiKeyAttempts: attempts,
+    _agentflowCursorApiKeyAttemptIndex: attemptIndex + 1,
+  };
+}
+
+function cursorResultErrorText(event) {
+  if (!event || typeof event !== "object") return "";
+  const candidates = [
+    event.result,
+    event.message,
+    event.error,
+    event.error?.message,
+    event.error?.error,
+    event.data?.error,
+    event.data?.message,
+  ];
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) return value;
+    if (value && typeof value === "object") {
+      const nested = value.message || value.error || value.result;
+      if (typeof nested === "string" && nested.trim()) return nested;
+    }
+  }
+  return "";
+}
+
 function writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, text) {
   const body = String(text ?? "").trim();
   if (!body) return;
@@ -298,6 +345,12 @@ export function runCursorAgentForNode(
   const rawPrefix = options.outputPrefix != null ? `[${options.outputPrefix}] ` : "";
   const coloredPrefix = rawPrefix && options.prefixColor ? options.prefixColor(rawPrefix) : rawPrefix;
   const agentContentColor = options.contentColor ?? ((line) => chalk.gray(line));
+  const {
+    baseEnv: cursorBaseEnv,
+    attempts: cursorAttempts,
+    attemptIndex: cursorAttemptIndex,
+    selection: cursorSelection,
+  } = cursorAttemptOptions(options);
 
   return new Promise((resolve, reject) => {
     const agentCmd = process.env.CURSOR_AGENT_CMD || "agent";
@@ -310,6 +363,15 @@ export function runCursorAgentForNode(
     if (options.flowName && options.uuid) {
       const argvLog = args.slice(0, -1).concat([`(prompt ${args[args.length - 1].length} chars)`]);
       appendRunLogLine(workspaceRoot, options.flowName, options.uuid, "cli-raw", `Cursor CLI 完整参数: ${agentCmd} ${JSON.stringify(argvLog)}`);
+      if (cursorAttempts.length > 1) {
+        appendRunLogLine(
+          workspaceRoot,
+          options.flowName,
+          options.uuid,
+          "cli-raw",
+          `Cursor API Key 尝试: ${cursorApiKeyLabel(cursorSelection)} / ${cursorAttempts.length}`,
+        );
+      }
       appendRunLogLine(
         workspaceRoot,
         options.flowName,
@@ -324,11 +386,12 @@ export function runCursorAgentForNode(
       cwd: execWorkspaceRoot,
       stdio: ["ignore", "pipe", useStderrInherit ? "inherit" : "pipe"],
       shell: false,
-      env: childEnv(options),
+      env: childEnv(options, cursorApiKeyEnv(cursorSelection)),
     });
 
     let lastResult = null;
     let hadError = false;
+    let hadToolActivity = false;
     const assistantTextChunks = [];
     const STDERR_CAP_BYTES = 1024 * 1024;
     const stderrChunks = [];
@@ -419,6 +482,7 @@ export function runCursorAgentForNode(
               if (out) writeStdout(out);
             }
           } else if (event.type === "tool_call") {
+            hadToolActivity = true;
             const toolName =
               event.tool_call && typeof event.tool_call === "object" ? Object.keys(event.tool_call)[0] ?? "?" : "?";
             const subtype = event.subtype ?? "";
@@ -438,6 +502,7 @@ export function runCursorAgentForNode(
         } catch (_) {
           let out;
           if (line.includes('"type":"tool_call"') || line.includes('"type": "tool_call"')) {
+            hadToolActivity = true;
             let subtype = "?";
             try {
               const ev = JSON.parse(line);
@@ -480,9 +545,27 @@ export function runCursorAgentForNode(
       if (coloredPrefix && stderrLineBuffer) {
         writeWithPrefix(process.stderr, stderrLineBuffer.endsWith("\n") ? stderrLineBuffer : stderrLineBuffer + "\n", coloredPrefix);
       }
+      const retryCursorQuota = (errorText) => {
+        if (!cursorSelection) return false;
+        if (cursorAttemptIndex >= cursorAttempts.length - 1) return false;
+        if (hadToolActivity) return false;
+        if (!isCursorQuotaError(errorText)) return false;
+        markCursorApiKeyQuotaBlocked(cursorSelection, cursorApiKeyCooldownMinutes(cursorBaseEnv));
+        const nextOptions = nextCursorAttemptOptions(options, cursorAttempts, cursorAttemptIndex);
+        const line = `[agentflow] Cursor API Key ${cursorApiKeyLabel(cursorSelection)} reached quota, retrying ${cursorAttemptIndex + 2}/${cursorAttempts.length}...\n`;
+        writeStdout(line);
+        if (flowName && uuid) appendRunLogLine(workspaceRoot, flowName, uuid, "cli-raw", line.trim());
+        runCursorAgentForNode(
+          workspaceRoot,
+          { promptPath, nodeContext, taskBody, intermediatePath, resultPathRel, subagent, instanceId },
+          nextOptions,
+        ).then(resolve).catch(reject);
+        return true;
+      };
       if (code !== 0 && lastResult == null) {
         const stderr = Buffer.concat(stderrChunks).toString("utf-8");
         const stderrTail = stderr ? stderr.trim().slice(-1200) : "";
+        if (retryCursorQuota(stderrTail)) return;
         const autoOnly =
           /named models unavailable/i.test(stderrTail) ||
           (/free plans?/i.test(stderrTail) && /only use auto/i.test(stderrTail)) ||
@@ -506,7 +589,9 @@ export function runCursorAgentForNode(
         return;
       }
       if (hadError || (lastResult && lastResult.is_error)) {
-        reject(new Error(lastResult?.result || "Agent reported error."));
+        const errorText = cursorResultErrorText(lastResult) || "Agent reported error.";
+        if (retryCursorQuota(errorText)) return;
+        reject(new Error(errorText));
         return;
       }
       writeAgentTextArtifacts(absResultPath, absRunDir, instanceId, assistantTextChunks.join("") || lastResult?.result || "");
@@ -1225,6 +1310,12 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
   const ws = path.resolve(cliWorkspace);
   const model = normalizeCursorModelForCli(options.model ?? process.env.CURSOR_AGENT_MODEL ?? null);
   const agentCmd = process.env.CURSOR_AGENT_CMD || "agent";
+  const {
+    baseEnv: cursorBaseEnv,
+    attempts: cursorAttempts,
+    attemptIndex: cursorAttemptIndex,
+    selection: cursorSelection,
+  } = cursorAttemptOptions(options);
   // Web UI Composer 需要能无交互执行本机 curl 等命令来刷新画布。
   const args = ["--print", "--output-format", "stream-json", "--trust", "--sandbox", "disabled", "--workspace", ws];
   const approveMcps = process.env.AGENTFLOW_CURSOR_APPROVE_MCPS !== "0" && process.env.AGENTFLOW_CURSOR_APPROVE_MCPS !== "false";
@@ -1238,11 +1329,12 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
     cwd: ws,
     stdio: ["ignore", "pipe", useStderrInherit ? "inherit" : "pipe"],
     shell: false,
-    env: childEnv(options),
+    env: childEnv(options, cursorApiKeyEnv(cursorSelection)),
   });
 
   let lastResult = null;
   let hadError = false;
+  let hadToolActivity = false;
   const STDERR_CAP_BYTES = 1024 * 1024;
   const stderrChunks = [];
   let stderrTotalBytes = 0;
@@ -1254,6 +1346,13 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
     } catch (_) {}
   };
 
+  if (cursorAttempts.length > 1) {
+    emit({
+      type: "status",
+      line: `Cursor API Key ${cursorApiKeyLabel(cursorSelection)} / ${cursorAttempts.length}`,
+    });
+  }
+
   if (!useStderrInherit) {
     child.stderr.on("data", (chunk) => {
       const s = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
@@ -1314,6 +1413,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
             emit({ type: "status", line: t("runner.generating_reply") });
           }
         } else if (event.type === "tool_call") {
+          hadToolActivity = true;
           const toolName =
             event.tool_call && typeof event.tool_call === "object" ? Object.keys(event.tool_call)[0] ?? "?" : "?";
           const subtype = event.subtype ?? "";
@@ -1347,6 +1447,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
       } catch (_) {
         emit({ type: "raw", source: "cursor", stream: "stdout", eventType: "line", text: rawTraceText(line) });
         if (line.includes('"type":"tool_call"') || line.includes('"type": "tool_call"')) {
+          hadToolActivity = true;
           let subtype = "?";
           try {
             const ev = JSON.parse(line);
@@ -1389,9 +1490,28 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
         const rest = stderrComposerBuffer.trim();
         emit({ type: "status", line: `[stderr] ${truncateComposerLine(rest)}` });
       }
+      const retryCursorQuota = (errorText) => {
+        if (!cursorSelection) return false;
+        if (cursorAttemptIndex >= cursorAttempts.length - 1) return false;
+        if (hadToolActivity) return false;
+        if (!isCursorQuotaError(errorText)) return false;
+        markCursorApiKeyQuotaBlocked(cursorSelection, cursorApiKeyCooldownMinutes(cursorBaseEnv));
+        emit({
+          type: "status",
+          line: `Cursor API Key ${cursorApiKeyLabel(cursorSelection)} reached quota, retrying ${cursorAttemptIndex + 2}/${cursorAttempts.length}`,
+        });
+        const next = runCursorAgentWithPrompt(
+          cliWorkspace,
+          promptText,
+          nextCursorAttemptOptions(options, cursorAttempts, cursorAttemptIndex),
+        );
+        next.finished.then(resolve).catch(reject);
+        return true;
+      };
       if (code !== 0 && lastResult == null) {
         const stderr = Buffer.concat(stderrChunks).toString("utf-8");
         const stderrTail = stderr ? stderr.trim().slice(-1200) : "";
+        if (retryCursorQuota(stderrTail)) return;
         const err = new Error(`Cursor CLI exited ${code}. ${stderrTail || "No result event received."}`);
         err.cursorStderrTail = stderrTail;
         emit({ type: "status", line: truncateComposerLine(err.message) });
@@ -1399,7 +1519,8 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
         return;
       }
       if (hadError || (lastResult && lastResult.is_error)) {
-        const msg = lastResult?.result || "Agent reported error.";
+        const msg = cursorResultErrorText(lastResult) || "Agent reported error.";
+        if (retryCursorQuota(msg)) return;
         emit({ type: "status", line: truncateComposerLine(msg) });
         reject(new Error(msg));
         return;

package/bin/lib/cursor-api-key-pool.mjs

@@ -0,0 +1,70 @@
+let nextCursorApiKeyCursor = 0;
+const cursorApiKeyBlockedUntil = new Map();
+
+export function parseCursorApiKeyPool(value = "") {
+  const raw = String(value || "").trim();
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed
+        .map((item) => {
+          if (typeof item === "string") return item.trim();
+          if (item && typeof item === "object") return String(item.key || "").trim();
+          return "";
+        })
+        .filter(Boolean);
+    }
+  } catch {
+    // Legacy comma-separated format.
+  }
+  return raw.split(",").map((key) => key.trim()).filter(Boolean);
+}
+
+export function createCursorApiKeyAttempts(env = {}) {
+  const keys = parseCursorApiKeyPool(env.CURSOR_API_KEYS);
+  if (keys.length === 0) return [undefined];
+
+  const now = Date.now();
+  const candidates = keys
+    .map((key, index) => ({ key, index, total: keys.length }))
+    .filter((selection) => (cursorApiKeyBlockedUntil.get(selection.index) || 0) <= now);
+  const effective = candidates.length > 0 ? candidates : keys.map((key, index) => ({ key, index, total: keys.length }));
+  const start = nextCursorApiKeyCursor % effective.length;
+  nextCursorApiKeyCursor += 1;
+  return [...effective.slice(start), ...effective.slice(0, start)];
+}
+
+export function cursorApiKeyEnv(selection) {
+  return selection && selection.key ? { CURSOR_API_KEY: selection.key } : {};
+}
+
+export function markCursorApiKeyQuotaBlocked(selection, cooldownMinutes = 30) {
+  if (!selection || !Number.isFinite(selection.index)) return;
+  const minutes = Math.max(1, Number(cooldownMinutes) || 30);
+  cursorApiKeyBlockedUntil.set(selection.index, Date.now() + minutes * 60 * 1000);
+}
+
+export function cursorApiKeyLabel(selection) {
+  if (!selection) return "default";
+  return `${selection.index + 1}/${selection.total}`;
+}
+
+export function isCursorQuotaError(error = "") {
+  const text = String(error || "");
+  if (!text) return false;
+  return [
+    /\b429\b/i,
+    /rate[_\s-]*limit/i,
+    /too many requests/i,
+    /quota/i,
+    /usage\s+limit/i,
+    /limit\s+(?:exceeded|reached)/i,
+    /exceeded\s+(?:your\s+)?limit/i,
+    /ActionRequiredError/i,
+  ].some((pattern) => pattern.test(text));
+}
+
+export function cursorApiKeyCooldownMinutes(env = {}) {
+  return Math.max(1, Number(env.AGENTFLOW_CURSOR_API_KEY_COOLDOWN_MINUTES || env.CURSOR_API_KEY_COOLDOWN_MINUTES || 30) || 30);
+}

package/bin/lib/ui-server.mjs

@@ -1682,6 +1682,103 @@ function writeUserWorkspaces(userCtx = {}, entries = []) {
   return workspaces;
 }
 
+function redactWorkspaceSecret(text = "", secret = "") {
+  let out = String(text || "");
+  const raw = String(secret || "");
+  if (!raw) return out;
+  out = out.split(raw).join("<redacted>");
+  try {
+    out = out.split(encodeURIComponent(raw)).join("<redacted>");
+  } catch {
+    // ignore invalid encoding edge cases
+  }
+  return out;
+}
+
+function workspaceRepoUrlWithCredential(repoUrl = "", credential = "") {
+  const token = String(credential || "").trim();
+  if (!token) return String(repoUrl || "").trim();
+  try {
+    const u = new URL(String(repoUrl || "").trim());
+    if (!/^https?:$/.test(u.protocol)) return String(repoUrl || "").trim();
+    if (!u.username) u.username = "oauth2";
+    u.password = token;
+    return u.toString();
+  } catch {
+    return String(repoUrl || "").trim();
+  }
+}
+
+function gitWorkspaceCommandOrThrow(args, cwd, label, secret = "") {
+  const result = runGit(args, cwd);
+  if (result.status !== 0) {
+    const message = redactWorkspaceSecret(result.stderr || result.stdout || result.error?.message || "unknown error", secret);
+    throw new Error(`${label} failed: ${message}`);
+  }
+  return {
+    stdout: redactWorkspaceSecret(result.stdout || "", secret),
+    stderr: redactWorkspaceSecret(result.stderr || "", secret),
+  };
+}
+
+function syncGitWorkspace(entry = {}, userCtx = {}) {
+  const workspace = normalizeWorkspaceEntry(entry, 0, userCtx);
+  if (!workspace || workspace.kind !== "git") throw new Error("只能拉取 Git 工作区");
+  if (!workspace.repoUrl) throw new Error("Git 工作区缺少 repoUrl");
+  const env = readMergedEnvObject(userCtx.userId || "");
+  const token = workspace.credentialRef ? String(env[workspace.credentialRef] || "").trim() : "";
+  const repoUrl = workspaceRepoUrlWithCredential(workspace.repoUrl, token);
+  const targetDir = path.resolve(workspace.path);
+  const parentDir = path.dirname(targetDir);
+  fs.mkdirSync(parentDir, { recursive: true });
+
+  const lines = [];
+  let changed = false;
+  if (fs.existsSync(path.join(targetDir, ".git"))) {
+    const originalRemote = runGit(["remote", "get-url", "origin"], targetDir).stdout.trim();
+    try {
+      if (token) gitWorkspaceCommandOrThrow(["remote", "set-url", "origin", repoUrl], targetDir, "git remote set-url", token);
+      const before = runGit(["rev-parse", "HEAD"], targetDir).stdout.trim();
+      gitWorkspaceCommandOrThrow(["fetch", "origin", "--prune"], targetDir, "git fetch", token);
+      if (workspace.branch) {
+        const checkout = runGit(["checkout", workspace.branch], targetDir);
+        if (checkout.status !== 0) {
+          gitWorkspaceCommandOrThrow(["checkout", "-b", workspace.branch, `origin/${workspace.branch}`], targetDir, "git checkout", token);
+        }
+        gitWorkspaceCommandOrThrow(["pull", "--ff-only", "origin", workspace.branch], targetDir, "git pull", token);
+      } else {
+        gitWorkspaceCommandOrThrow(["pull", "--ff-only"], targetDir, "git pull", token);
+      }
+      const after = runGit(["rev-parse", "HEAD"], targetDir).stdout.trim();
+      changed = before !== after;
+      lines.push(changed ? `updated ${before.slice(0, 8)} -> ${after.slice(0, 8)}` : `already up to date ${after.slice(0, 8)}`);
+    } finally {
+      if (token && originalRemote) runGit(["remote", "set-url", "origin", originalRemote], targetDir);
+    }
+  } else {
+    if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+      throw new Error(`目标路径已存在但不是 Git 仓库：${targetDir}`);
+    }
+    const args = ["clone"];
+    if (workspace.branch) args.push("--branch", workspace.branch);
+    args.push(repoUrl, targetDir);
+    gitWorkspaceCommandOrThrow(args, parentDir, "git clone", token);
+    const commit = runGit(["rev-parse", "HEAD"], targetDir).stdout.trim();
+    changed = true;
+    lines.push(`cloned ${commit.slice(0, 8)}`);
+    if (token) runGit(["remote", "set-url", "origin", workspace.repoUrl], targetDir);
+  }
+  const branch = runGit(["rev-parse", "--abbrev-ref", "HEAD"], targetDir).stdout.trim();
+  const commit = runGit(["rev-parse", "HEAD"], targetDir).stdout.trim();
+  return {
+    workspace: normalizeWorkspaceEntry({ ...workspace, path: targetDir }, 0, userCtx),
+    changed,
+    branch,
+    commit,
+    message: lines.join("\n"),
+  };
+}
+
 function listConfiguredWorkspaces(root, scopedRoot, userCtx = {}) {
   const currentRoot = path.resolve(scopedRoot || root);
   const homeRoot = path.resolve(os.homedir());
@@ -7667,7 +7764,7 @@ export function startUiServer({
 
     if (req.method === "POST" && url.pathname === "/api/workspaces") {
       try {
-        const payload = await readJson(req);
+        const payload = JSON.parse(await readBody(req));
         const customWorkspaces = writeUserWorkspaces(userCtx, payload?.workspaces || payload?.customWorkspaces || []);
         json(res, 200, {
           path: userWorkspacesPath(userCtx),
@@ -7680,6 +7777,29 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workspaces/sync") {
+      try {
+        const payload = JSON.parse(await readBody(req));
+        const id = String(payload?.id || "").trim();
+        const workspaces = readUserWorkspaces(userCtx);
+        const workspace = workspaces.find((entry) => String(entry.id || "") === id);
+        if (!workspace) {
+          json(res, 404, { error: "工作区不存在" });
+          return;
+        }
+        const result = syncGitWorkspace(workspace, userCtx);
+        json(res, 200, {
+          ok: true,
+          ...result,
+          workspaces: listConfiguredWorkspaces(root, root, userCtx),
+          customWorkspaces: readUserWorkspaces(userCtx),
+        });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/api/workspace/graph") {
       try {
         const scoped = resolveWorkspaceScopeRoot(root, {