@fieldwangai/agentflow 0.1.165 → 0.1.167

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

@@ -1,71 +1,285 @@
+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,
+      createdAt: String(item.createdAt || "").trim(),
+    };
+  };
   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 parseCursorApiKeyPool(value = "") {
+  return parseCursorApiKeyRecords(value).map((record) => record.key);
 }
 
-export function createCursorApiKeyAttempts(env = {}) {
-  const keys = parseCursorApiKeyPool(env.CURSOR_API_KEYS);
-  if (keys.length === 0) return [undefined];
+export function createCursorApiKeyAttempts(env = {}, now = Date.now()) {
+  const records = parseCursorApiKeyRecords(env.CURSOR_API_KEYS);
+  if (records.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 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(),
+  evidence = {},
+) {
+  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);
+  const fallbackModel = keyState.fallbackModel;
+  const lastFailure = {
+    triggeredAt: new Date(now).toISOString(),
+    ...(errorCategory ? { errorCategory } : {}),
+    errorPreview: sanitizeErrorPreview(errorText),
+    lane,
+    modelId: String(evidence?.modelId || (lane === "auto" ? "auto" : fallbackModel?.id || "fallback")),
+    modelName: String(evidence?.modelName || (lane === "auto" ? "Auto" : fallbackModel?.displayName || "降级模型")),
+  };
+  keyState[lane] = {
+    ...currentLane,
+    blockedUntil,
+    ...(errorCategory ? { errorCategory } : {}),
+    ...(lane === "auto" ? { fallbackEligible: isCursorAutoFallbackEligible(errorText) } : {}),
+    lastFailure,
+  };
+  keyState.lastFailure = lastFailure;
+  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 clearCursorApiKeyCooldown(keyOrSelection) {
+  const keyState = cursorApiKeyStates.get(selectionId(keyOrSelection));
+  if (!keyState) return false;
+  let changed = false;
+  for (const lane of ["auto", "fallback"]) {
+    if (!keyState[lane] || (keyState[lane].blockedUntil || 0) <= 0) continue;
+    keyState[lane].blockedUntil = 0;
+    delete keyState[lane].errorCategory;
+    delete keyState[lane].fallbackEligible;
+    changed = true;
+  }
+  return changed;
+}
+
+export function recordCursorApiKeyUsage(keyOrSelection, selection = {}, now = Date.now()) {
+  const keyId = selectionId(keyOrSelection);
+  if (!keyId || keyId === "default") return;
+  const keyState = cursorApiKeyStates.get(keyId) || {};
+  keyState.lastUsedAt = new Date(now).toISOString();
+  keyState.lastSelection = {
+    lane: selection?.lane === "fallback" ? "fallback" : "auto",
+    modelId: String(selection?.modelId || "auto"),
+    modelName: String(selection?.modelName || "Auto"),
+  };
+  cursorApiKeyStates.set(keyId, keyState);
+}
+
+export function getCursorApiKeyPoolStatuses(records = [], now = Date.now()) {
+  return (Array.isArray(records) ? records : []).map((record) => {
+    const id = selectionId(record);
+    const keyState = cursorApiKeyStates.get(id);
+    const selection = getCursorApiKeyModelSelection(id, now);
+    const laneCooldowns = buildLaneCooldowns(keyState, now);
+    const common = {
+      id,
+      ...(keyState?.lastUsedAt ? { lastUsedAt: keyState.lastUsedAt } : {}),
+      ...(keyState?.fallbackModel ? { fallbackModel: keyState.fallbackModel } : {}),
+      laneCooldowns,
+      ...(keyState?.lastFailure ? { lastFailure: keyState.lastFailure } : {}),
+    };
+    if (selection) {
+      return {
+        ...common,
+        status: "available",
+        activeLane: selection.lane,
+        activeModelId: selection.modelId,
+        activeModelName: selection.modelName,
+        degraded: selection.lane === "fallback",
+      };
+    }
+    const activeCooldowns = laneCooldowns.filter((item) => item.remainingSeconds > 0);
+    const earliest = activeCooldowns.reduce(
+      (result, item) => !result || item.remainingSeconds < result.remainingSeconds ? item : result,
+      undefined,
+    );
+    const autoState = keyState?.auto;
+    return {
+      ...common,
+      status: "cooling_down",
+      ...(autoState?.errorCategory ? { errorCategory: autoState.errorCategory } : {}),
+      blockedUntil: earliest?.blockedUntil || new Date(Math.max(now, autoState?.blockedUntil || now)).toISOString(),
+      remainingSeconds: earliest?.remainingSeconds || Math.max(0, Math.ceil(((autoState?.blockedUntil || now) - now) / 1000)),
+    };
+  });
+}
+
+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 || "");
+  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 false;
-  return [
+  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 = {}) {
+export function cursorApiKeyCooldownMinutes(env = {}, errorText = "") {
+  if (classifyCursorApiKeyLimitError(errorText) === "resource_exhausted") {
+    return Math.max(1, Number(env.AGENTFLOW_CURSOR_API_KEY_RESOURCE_EXHAUSTED_COOLDOWN_MINUTES || 3) || 3);
+  }
   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)}`;
+}
+
+function buildLaneCooldowns(keyState, now) {
+  if (!keyState) return [];
+  const lanes = [];
+  for (const lane of ["auto", "fallback"]) {
+    const laneState = keyState[lane];
+    if (!laneState || (laneState.blockedUntil || 0) <= now) continue;
+    const fallbackModel = keyState.fallbackModel;
+    lanes.push({
+      lane,
+      modelId: lane === "auto" ? "auto" : fallbackModel?.id || "fallback",
+      modelName: lane === "auto" ? "Auto" : fallbackModel?.displayName || "降级模型",
+      ...(laneState.errorCategory ? { errorCategory: laneState.errorCategory } : {}),
+      blockedUntil: new Date(laneState.blockedUntil).toISOString(),
+      remainingSeconds: Math.ceil((laneState.blockedUntil - now) / 1000),
+    });
+  }
+  return lanes;
+}
+
+function sanitizeErrorPreview(errorText) {
+  return String(errorText || "").replace(/(?:sk|key)[-_][A-Za-z0-9_-]{8,}/gi, "[redacted]").trim().slice(0, 500);
+}

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/repository-index-events.mjs

@@ -0,0 +1,17 @@
+const runFinishedListeners = new Set();
+
+export function onRepositoryRunFinished(listener) {
+  if (typeof listener !== "function") return () => {};
+  runFinishedListeners.add(listener);
+  return () => runFinishedListeners.delete(listener);
+}
+
+export function emitRepositoryRunFinished(workspaceRoot, run, status) {
+  for (const listener of runFinishedListeners) {
+    try {
+      listener(workspaceRoot, run, status);
+    } catch {
+      // Derived repository updates must never break the authoritative run ledger.
+    }
+  }
+}