@fieldwangai/agentflow 0.1.166 → 0.1.168

package/bin/lib/composer-agent.mjs

@@ -319,6 +319,11 @@ function runCursorAgentWithPrivateMcp(cliWorkspace, prompt, options, userId) {
  * @param {string} [opts.modelKey]
  * @param {Record<string, string>} [opts.extraEnv]
  * @param {boolean} [opts.force]
+ * @param {"ask" | "plan"} [opts.mode]
+ * @param {boolean} [opts.sandboxDisabled]
+ * @param {boolean} [opts.approveMcps]
+ * @param {"read-only" | "workspace-write" | "danger-full-access"} [opts.sandboxMode]
+ * @param {boolean} [opts.includeJsonResult]
  * @param {(ev: object) => void} [opts.onStreamEvent]
  * @param {(subtype: string, toolName: string) => void} [opts.onToolCall]
  * @returns {{ child: import('child_process').ChildProcess, finished: Promise<void> }}
@@ -343,6 +348,12 @@ export function startComposerAgent(opts) {
     onChild: opts.onChild,
     detached: Boolean(opts.detached),
     force: Boolean(opts.force),
+    ...(opts.mode ? { mode: String(opts.mode) } : {}),
+    ...(opts.sandboxDisabled === false ? { sandboxDisabled: false } : {}),
+    ...(typeof opts.approveMcps === "boolean" ? { approveMcps: opts.approveMcps } : {}),
+    ...(opts.sandboxMode ? { sandboxMode: String(opts.sandboxMode) } : {}),
+    ...(opts.allowDanger === false ? { allowDanger: false } : {}),
+    ...(opts.includeJsonResult === true ? { includeJsonResult: true } : {}),
     env,
     addDirs: Array.isArray(opts.writableDirs)
       ? opts.writableDirs.map((dir) => String(dir || "").trim()).filter(Boolean)

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

@@ -18,6 +18,7 @@ export function parseCursorApiKeyRecords(value = "") {
       id: String(item.id || "").trim() || legacyKeyId(key),
       name: String(item.name || "").trim() || `Key ${index + 1}`,
       key,
+      createdAt: String(item.createdAt || "").trim(),
     };
   };
   try {
@@ -89,6 +90,7 @@ export function markCursorApiKeyLaneBlocked(
   cooldownMinutes = 30,
   errorText = "",
   now = Date.now(),
+  evidence = {},
 ) {
   const keyId = selectionId(keyOrSelection);
   if (!keyId || !["auto", "fallback"].includes(lane)) return 0;
@@ -97,12 +99,23 @@ export function markCursorApiKeyLaneBlocked(
   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;
 }
@@ -116,6 +129,72 @@ export function clearCursorApiKeyLaneCooldown(keyOrSelection, lane) {
   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 } : {};
 }
@@ -159,7 +238,10 @@ 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);
 }
 
@@ -178,3 +260,26 @@ function selectionId(keyOrSelection) {
 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/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.
+    }
+  }
+}