@fieldwangai/agentflow 0.1.164 → 0.1.166

package/bin/lib/agent-runners.mjs

@@ -7,13 +7,18 @@ import { normalizeCursorModelForCli } from "./model-config.mjs";
 import { t } from "./i18n.mjs";
 import { readMergedEnvObject } from "./user-env.mjs";
 import {
+  classifyCursorApiKeyLimitError,
+  clearCursorApiKeyLaneCooldown,
   createCursorApiKeyAttempts,
   cursorApiKeyCooldownMinutes,
   cursorApiKeyEnv,
   cursorApiKeyLabel,
+  isCursorAutoFallbackEligible,
   isCursorQuotaError,
-  markCursorApiKeyQuotaBlocked,
+  markCursorApiKeyLaneBlocked,
+  recordCursorApiKeyFallbackModel,
 } from "./cursor-api-key-pool.mjs";
+import { discoverCursorModels } from "./cursor-model-catalog.mjs";
 import { outputNodeBasename } from "../pipeline/get-exec-id.mjs";
 
 function shouldPassCursorModelArg(model) {
@@ -53,6 +58,16 @@ function nextCursorAttemptOptions(options = {}, attempts = [], attemptIndex = 0)
     ...options,
     _agentflowCursorApiKeyAttempts: attempts,
     _agentflowCursorApiKeyAttemptIndex: attemptIndex + 1,
+    _agentflowCursorModelSelection: undefined,
+  };
+}
+
+function cursorModelAttemptOptions(options = {}, attempts = [], attemptIndex = 0, modelSelection) {
+  return {
+    ...options,
+    _agentflowCursorApiKeyAttempts: attempts,
+    _agentflowCursorApiKeyAttemptIndex: attemptIndex,
+    _agentflowCursorModelSelection: modelSelection,
   };
 }
 
@@ -402,7 +417,7 @@ function tryEmitOpenCodeLineAsNatural(line, emit) {
 export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {}) {
   const onStreamEvent = typeof options.onStreamEvent === "function" ? options.onStreamEvent : null;
   const ws = path.resolve(cliWorkspace);
-  const model = normalizeCursorModelForCli(options.model ?? process.env.CURSOR_AGENT_MODEL ?? null);
+  const requestedModel = normalizeCursorModelForCli(options.model ?? process.env.CURSOR_AGENT_MODEL ?? null);
   const agentCmd = process.env.CURSOR_AGENT_CMD || "agent";
   const {
     baseEnv: cursorBaseEnv,
@@ -410,6 +425,13 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
     attemptIndex: cursorAttemptIndex,
     selection: cursorSelection,
   } = cursorAttemptOptions(options);
+  const hasExplicitModel = shouldPassCursorModelArg(requestedModel);
+  const cursorModelSelection = hasExplicitModel
+    ? { lane: "auto", modelId: requestedModel, modelName: requestedModel }
+    : options._agentflowCursorModelSelection
+      || cursorSelection?.modelSelection
+      || { lane: "auto", modelId: "auto", modelName: "Auto" };
+  const model = hasExplicitModel ? requestedModel : cursorModelSelection.modelId;
   // 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";
@@ -448,6 +470,12 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
       line: `Cursor API Key ${cursorApiKeyLabel(cursorSelection)} / ${cursorAttempts.length}`,
     });
   }
+  if (cursorModelSelection.lane === "fallback") {
+    emit({
+      type: "status",
+      line: `Cursor is using Composer fallback: ${cursorModelSelection.modelName}`,
+    });
+  }
 
   if (!useStderrInherit) {
     child.stderr.on("data", (chunk) => {
@@ -588,20 +616,83 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
       }
       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),
+        const errorCategory = classifyCursorApiKeyLimitError(errorText);
+        const cooldownMinutes = cursorApiKeyCooldownMinutes(cursorBaseEnv);
+        markCursorApiKeyLaneBlocked(
+          cursorSelection,
+          cursorModelSelection.lane,
+          cooldownMinutes,
+          errorText,
         );
-        next.finished.then(resolve).catch(reject);
+        const canTryComposer = !hasExplicitModel
+          && cursorModelSelection.lane === "auto"
+          && errorCategory === "explicit_limit"
+          && isCursorAutoFallbackEligible(errorText);
+        const hasNextKey = cursorAttemptIndex < cursorAttempts.length - 1;
+        if (!canTryComposer && !hasNextKey) return false;
+
+        const retry = async () => {
+          if (canTryComposer) {
+            emit({
+              type: "status",
+              line: `Cursor Auto on API Key ${cursorApiKeyLabel(cursorSelection)} is out of usage; discovering Composer fallback...`,
+            });
+            const catalog = await discoverCursorModels({
+              keyId: cursorSelection.id,
+              cwd: ws,
+              command: agentCmd,
+              env: childEnv(options, cursorApiKeyEnv(cursorSelection)),
+            });
+            if (catalog.fallbackModel) {
+              recordCursorApiKeyFallbackModel(cursorSelection, catalog.fallbackModel);
+              const fallbackSelection = {
+                lane: "fallback",
+                modelId: catalog.fallbackModel.id,
+                modelName: catalog.fallbackModel.displayName,
+              };
+              emit({
+                type: "status",
+                line: `Switching the same Cursor API Key to ${fallbackSelection.modelName}.`,
+              });
+              emit({
+                type: "raw",
+                source: "cursor",
+                stream: "runner",
+                eventType: "model_fallback",
+                text: `auto -> ${fallbackSelection.modelId}`,
+              });
+              const fallback = runCursorAgentWithPrompt(
+                cliWorkspace,
+                promptText,
+                cursorModelAttemptOptions(options, cursorAttempts, cursorAttemptIndex, fallbackSelection),
+              );
+              await fallback.finished;
+              return;
+            }
+            emit({
+              type: "status",
+              line: `Composer fallback is unavailable${catalog.error ? `: ${catalog.error}` : "."}`,
+            });
+          }
+
+          if (hasNextKey) {
+            emit({
+              type: "status",
+              line: `Cursor API Key ${cursorApiKeyLabel(cursorSelection)} reached its limit; retrying ${cursorAttemptIndex + 2}/${cursorAttempts.length}.`,
+            });
+            const next = runCursorAgentWithPrompt(
+              cliWorkspace,
+              promptText,
+              nextCursorAttemptOptions(options, cursorAttempts, cursorAttemptIndex),
+            );
+            await next.finished;
+            return;
+          }
+          throw new Error(errorText || "Cursor API Key reached its limit.");
+        };
+        retry().then(resolve).catch(reject);
         return true;
       };
       if (code !== 0 && lastResult == null) {
@@ -622,6 +713,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
         reject(new Error(msg));
         return;
       }
+      if (cursorSelection) clearCursorApiKeyLaneCooldown(cursorSelection, cursorModelSelection.lane);
       resolve();
     });
   });

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

@@ -1,71 +1,180 @@
+import { createHash } from "node:crypto";
+
 let nextCursorApiKeyCursor = 0;
-const cursorApiKeyBlockedUntil = new Map();
+const cursorApiKeyStates = new Map();
 
-export function parseCursorApiKeyPool(value = "") {
+export function parseCursorApiKeyRecords(value = "") {
   const raw = String(value || "").trim();
   if (!raw) return [];
+  const normalizeRecord = (item, index) => {
+    if (typeof item === "string") {
+      const key = item.trim();
+      return key ? { id: legacyKeyId(key), name: `Key ${index + 1}`, key } : null;
+    }
+    if (!item || typeof item !== "object") return null;
+    const key = String(item.key || "").trim();
+    if (!key) return null;
+    return {
+      id: String(item.id || "").trim() || legacyKeyId(key),
+      name: String(item.name || "").trim() || `Key ${index + 1}`,
+      key,
+    };
+  };
   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);
-    }
+    if (Array.isArray(parsed)) return parsed.map(normalizeRecord).filter(Boolean);
   } catch {
     // Legacy comma-separated format.
   }
-  return raw.split(",").map((key) => key.trim()).filter(Boolean);
+  return raw.split(",").map(normalizeRecord).filter(Boolean);
 }
 
-export function createCursorApiKeyAttempts(env = {}) {
-  const keys = parseCursorApiKeyPool(env.CURSOR_API_KEYS);
-  if (keys.length === 0) return [undefined];
+export function parseCursorApiKeyPool(value = "") {
+  return parseCursorApiKeyRecords(value).map((record) => record.key);
+}
 
-  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 }));
+export function createCursorApiKeyAttempts(env = {}, now = Date.now()) {
+  const records = parseCursorApiKeyRecords(env.CURSOR_API_KEYS);
+  if (records.length === 0) return [undefined];
+
+  const selections = records.map((record, index) => ({
+    ...record,
+    index,
+    total: records.length,
+    modelSelection: getCursorApiKeyModelSelection(record.id, now),
+  }));
+  const candidates = selections.filter((selection) => Boolean(selection.modelSelection));
+  // Preserve the old pool's last-resort behavior if every key is cooling down.
+  // Normal operation always uses candidates and therefore respects lane cooldowns.
+  const effective = candidates.length > 0
+    ? candidates
+    : selections.map((selection) => ({
+        ...selection,
+        modelSelection: { lane: "auto", modelId: "auto", modelName: "Auto" },
+      }));
   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 getCursorApiKeyModelSelection(keyOrSelection, now = Date.now()) {
+  const keyId = selectionId(keyOrSelection);
+  const keyState = cursorApiKeyStates.get(keyId);
+  const autoBlocked = (keyState?.auto?.blockedUntil || 0) > now;
+  if (!autoBlocked) return { lane: "auto", modelId: "auto", modelName: "Auto" };
+
+  if (keyState?.auto?.errorCategory !== "explicit_limit" || keyState.auto.fallbackEligible !== true) {
+    return undefined;
+  }
+  const fallbackModel = keyState.fallbackModel;
+  if (!fallbackModel || (keyState.fallback?.blockedUntil || 0) > now) return undefined;
+  return {
+    lane: "fallback",
+    modelId: fallbackModel.id,
+    modelName: fallbackModel.displayName,
+  };
+}
+
+export function recordCursorApiKeyFallbackModel(keyOrSelection, model) {
+  if (!model?.id) return;
+  const keyId = selectionId(keyOrSelection);
+  const keyState = cursorApiKeyStates.get(keyId) || {};
+  keyState.fallbackModel = { ...model };
+  cursorApiKeyStates.set(keyId, keyState);
 }
 
-export function markCursorApiKeyQuotaBlocked(selection, cooldownMinutes = 30) {
-  if (!selection || !Number.isFinite(selection.index)) return;
+export function markCursorApiKeyLaneBlocked(
+  keyOrSelection,
+  lane,
+  cooldownMinutes = 30,
+  errorText = "",
+  now = Date.now(),
+) {
+  const keyId = selectionId(keyOrSelection);
+  if (!keyId || !["auto", "fallback"].includes(lane)) return 0;
   const minutes = Math.max(1, Number(cooldownMinutes) || 30);
-  cursorApiKeyBlockedUntil.set(selection.index, Date.now() + minutes * 60 * 1000);
+  const keyState = cursorApiKeyStates.get(keyId) || {};
+  const currentLane = keyState[lane] || {};
+  const blockedUntil = Math.max(currentLane.blockedUntil || 0, now + minutes * 60 * 1000);
+  const errorCategory = classifyCursorApiKeyLimitError(errorText);
+  keyState[lane] = {
+    ...currentLane,
+    blockedUntil,
+    ...(errorCategory ? { errorCategory } : {}),
+    ...(lane === "auto" ? { fallbackEligible: isCursorAutoFallbackEligible(errorText) } : {}),
+  };
+  cursorApiKeyStates.set(keyId, keyState);
+  return blockedUntil;
+}
+
+export function clearCursorApiKeyLaneCooldown(keyOrSelection, lane) {
+  const keyState = cursorApiKeyStates.get(selectionId(keyOrSelection));
+  if (!keyState?.[lane]) return false;
+  keyState[lane].blockedUntil = 0;
+  delete keyState[lane].errorCategory;
+  delete keyState[lane].fallbackEligible;
+  return true;
+}
+
+export function cursorApiKeyEnv(selection) {
+  return selection?.key ? { CURSOR_API_KEY: selection.key } : {};
+}
+
+export function markCursorApiKeyQuotaBlocked(selection, cooldownMinutes = 30, errorText = "") {
+  return markCursorApiKeyLaneBlocked(selection, "auto", cooldownMinutes, errorText);
 }
 
 export function cursorApiKeyLabel(selection) {
   if (!selection) return "default";
-  return `${selection.index + 1}/${selection.total}`;
+  return selection.name ? `${selection.index + 1}/${selection.total} (${selection.name})` : `${selection.index + 1}/${selection.total}`;
 }
 
-export function isCursorQuotaError(error = "") {
+export function isCursorAutoFallbackEligible(error = "") {
   const text = String(error || "");
-  if (!text) return false;
-  return [
+  return [/\bout\s+of\s+usage\b/i, /\busage\s+limit\b/i].some((pattern) => pattern.test(text));
+}
+
+export function classifyCursorApiKeyLimitError(error = "") {
+  const text = String(error || "");
+  if (!text) return undefined;
+  const isExplicitLimit = [
     /\b429\b/i,
     /rate[_\s-]*limit/i,
     /too many requests/i,
     /quota/i,
     /usage\s+limit/i,
+    /out\s+of\s+usage/i,
     /limit\s+(?:exceeded|reached)/i,
     /exceeded\s+(?:your\s+)?limit/i,
-    /resource[_\s-]*exhausted/i,
-    /ActionRequiredError/i,
+    /insufficient[_\s-]*quota/i,
+    /credit[s]?\s+(?:exhausted|limit)/i,
+    /request\s+limit/i,
   ].some((pattern) => pattern.test(text));
+  if (isExplicitLimit) return "explicit_limit";
+  if (/resource[_\s-]*exhausted/i.test(text)) return "resource_exhausted";
+  return undefined;
+}
+
+export function isCursorQuotaError(error = "") {
+  return classifyCursorApiKeyLimitError(error) !== undefined;
 }
 
 export function cursorApiKeyCooldownMinutes(env = {}) {
   return Math.max(1, Number(env.AGENTFLOW_CURSOR_API_KEY_COOLDOWN_MINUTES || env.CURSOR_API_KEY_COOLDOWN_MINUTES || 30) || 30);
 }
+
+export function resetCursorApiKeyPoolForTests() {
+  nextCursorApiKeyCursor = 0;
+  cursorApiKeyStates.clear();
+}
+
+function selectionId(keyOrSelection) {
+  if (typeof keyOrSelection === "string") return keyOrSelection;
+  if (keyOrSelection?.id) return String(keyOrSelection.id);
+  if (keyOrSelection?.key) return legacyKeyId(String(keyOrSelection.key));
+  return "default";
+}
+
+function legacyKeyId(key) {
+  return `legacy_${createHash("sha256").update(String(key || "")).digest("hex").slice(0, 16)}`;
+}

package/bin/lib/cursor-model-catalog.mjs

@@ -0,0 +1,152 @@
+import { spawn } from "node:child_process";
+
+const MODEL_CATALOG_TIMEOUT_MS = 15_000;
+const MODEL_CATALOG_CACHE_MS = 15 * 60 * 1000;
+const MAX_CATALOG_OUTPUT_LENGTH = 64 * 1024;
+const ANSI_ESCAPE_PATTERN = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+
+const modelCatalogCache = new Map();
+
+export async function discoverCursorModels({
+  keyId,
+  cwd,
+  env,
+  command = "agent",
+  forceRefresh = false,
+} = {}) {
+  const now = Date.now();
+  const cacheKey = String(keyId || "default");
+  const cached = modelCatalogCache.get(cacheKey);
+  if (!forceRefresh && cached && cached.expiresAt > now) {
+    return buildCatalogResult(cached.models);
+  }
+
+  const commandResult = await runModelsCommand({ cwd, env, command });
+  if (!commandResult.success) return { models: [], error: commandResult.error };
+
+  const models = parseCursorModelsOutput(commandResult.output);
+  if (models.length === 0) {
+    return { models: [], error: "Cursor CLI did not return any available models." };
+  }
+  modelCatalogCache.set(cacheKey, {
+    expiresAt: now + MODEL_CATALOG_CACHE_MS,
+    models,
+  });
+  return buildCatalogResult(models);
+}
+
+export function parseCursorModelsOutput(output = "") {
+  const lines = stripAnsi(String(output || ""))
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const models = [];
+  let insideModelList = false;
+  for (const line of lines) {
+    if (/^available models$/i.test(line)) {
+      insideModelList = true;
+      continue;
+    }
+    if (/^tip:/i.test(line)) break;
+    if (!insideModelList || /^no models available/i.test(line)) continue;
+
+    const flagsMatch = line.match(/\s+\(((?:current|default)(?:,\s*(?:current|default))*)\)$/i);
+    const flags = flagsMatch?.[1]?.toLowerCase() || "";
+    const value = flagsMatch ? line.slice(0, flagsMatch.index).trim() : line;
+    const separatorIndex = value.indexOf(" - ");
+    const id = (separatorIndex >= 0 ? value.slice(0, separatorIndex) : value).trim();
+    const displayName = (separatorIndex >= 0 ? value.slice(separatorIndex + 3) : id).trim();
+    if (!id || (separatorIndex < 0 && /\s/.test(id))) continue;
+    models.push({
+      id,
+      displayName: displayName || id,
+      isDefault: flags.split(/,\s*/).includes("default"),
+      isCurrent: flags.split(/,\s*/).includes("current"),
+    });
+  }
+  return dedupeModels(models);
+}
+
+export function selectComposerFallbackModel(models = []) {
+  return models.find((model) => [model?.id, model?.displayName].some((value) =>
+    /(^|[^a-z0-9])composer(?=$|[^a-z0-9])/i.test(String(value || ""))
+  ));
+}
+
+export function clearCursorModelCatalogCache() {
+  modelCatalogCache.clear();
+}
+
+function buildCatalogResult(models) {
+  const fallback = selectComposerFallbackModel(models);
+  return {
+    models,
+    ...(fallback ? {
+      fallbackModel: {
+        id: fallback.id,
+        displayName: formatComposerModelName(fallback),
+        discoveredAt: new Date().toISOString(),
+      },
+    } : {}),
+  };
+}
+
+function runModelsCommand({ cwd, env, command }) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = spawn(command || "agent", ["models"], {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+    });
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      resolve(result);
+    };
+    const timeoutId = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({ success: false, error: "Cursor CLI model discovery timed out." });
+    }, MODEL_CATALOG_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_CATALOG_OUTPUT_LENGTH) stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_CATALOG_OUTPUT_LENGTH) stderr += chunk.toString();
+    });
+    child.on("error", (error) => finish({ success: false, error: error.message }));
+    child.on("exit", (code) => {
+      if (code === 0) {
+        finish({ success: true, output: stdout.slice(0, MAX_CATALOG_OUTPUT_LENGTH) });
+        return;
+      }
+      finish({
+        success: false,
+        error: stripAnsi(stderr || stdout || `Cursor CLI models exited with code ${code}`).trim().slice(0, 1000),
+      });
+    });
+  });
+}
+
+function stripAnsi(value) {
+  return String(value || "").replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+function formatComposerModelName(model) {
+  if (/(^|[^a-z0-9])composer(?=$|[^a-z0-9])/i.test(model.displayName)) return model.displayName;
+  if (model.displayName && model.displayName !== model.id) return `${model.id} · ${model.displayName}`;
+  return model.id;
+}
+
+function dedupeModels(models) {
+  const seen = new Set();
+  return models.filter((model) => {
+    if (seen.has(model.id)) return false;
+    seen.add(model.id);
+    return true;
+  });
+}

package/bin/lib/marketplace-usage.mjs

@@ -155,8 +155,9 @@ export function marketplaceFlowOriginPath(flowDir) {
 }
 
 export function writeMarketplaceFlowOrigin(flowDir, origin = {}) {
+  const kind = safeText(origin.kind, 32) === "project-flow" ? "project-flow" : "flow";
   const value = {
-    kind: "flow",
+    kind,
     id: safeText(origin.id),
     version: safeText(origin.version, 80),
     installedAt: safeText(origin.installedAt || new Date().toISOString(), 80),
@@ -169,8 +170,8 @@ export function writeMarketplaceFlowOrigin(flowDir, origin = {}) {
 export function readMarketplaceFlowOrigin(flowDir) {
   try {
     const parsed = JSON.parse(fs.readFileSync(marketplaceFlowOriginPath(flowDir), "utf-8"));
-    if (parsed?.kind !== "flow" || !parsed.id || !parsed.version) return null;
-    return { kind: "flow", id: String(parsed.id), version: String(parsed.version) };
+    if (!["flow", "project-flow"].includes(parsed?.kind) || !parsed.id || !parsed.version) return null;
+    return { kind: parsed.kind, id: String(parsed.id), version: String(parsed.version) };
   } catch {
     return null;
   }