@fieldwangai/agentflow 0.1.167 → 0.1.168

package/bin/lib/agent-runners.mjs

@@ -93,6 +93,28 @@ function cursorResultErrorText(event) {
   return "";
 }
 
+export function isCursorAgentLoopingError(error = "") {
+  const text = String(error?.message || error || "");
+  return /agent looping detected|got stuck in a repeating response pattern/i.test(text);
+}
+
+function isCursorReadOnlyToolCall(toolName = "") {
+  const name = String(toolName || "").trim();
+  if (!name) return false;
+  return /^(read|glob|grep|search|semanticSearch|list|find|fetch|webSearch|view|inspect)/i.test(name);
+}
+
+function annotateCursorFailure(error, { hadToolActivity = false, hadMutatingToolActivity = false } = {}) {
+  const failure = error instanceof Error ? error : new Error(String(error || "Cursor Agent failed."));
+  failure.cursorHadToolActivity = Boolean(hadToolActivity);
+  failure.cursorHadMutatingToolActivity = Boolean(hadMutatingToolActivity);
+  if (isCursorAgentLoopingError(failure)) {
+    failure.code = "CURSOR_AGENT_LOOPING";
+    failure.agentflowFailureCategory = "agent_looping";
+  }
+  return failure;
+}
+
 function envFlag(name, defaultValue = false) {
   const raw = process.env[name];
   if (raw == null || raw === "") return defaultValue;
@@ -459,6 +481,14 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
   let lastResult = null;
   let hadError = false;
   let hadToolActivity = false;
+  let hadMutatingToolActivity = false;
+  const annotateFailure = (error) => {
+    const failure = annotateCursorFailure(error, { hadToolActivity, hadMutatingToolActivity });
+    failure.cursorModelLane = cursorModelSelection.lane;
+    failure.cursorModelId = cursorModelSelection.modelId;
+    failure.cursorModelName = cursorModelSelection.modelName;
+    return failure;
+  };
   const STDERR_CAP_BYTES = 1024 * 1024;
   const stderrChunks = [];
   let stderrTotalBytes = 0;
@@ -546,6 +576,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
           hadToolActivity = true;
           const toolName =
             event.tool_call && typeof event.tool_call === "object" ? Object.keys(event.tool_call)[0] ?? "?" : "?";
+          if (!isCursorReadOnlyToolCall(toolName)) hadMutatingToolActivity = true;
           const subtype = event.subtype ?? "";
           const statusLine = `工具 ${toolName}${subtype ? ` (${subtype})` : ""}`;
           emit({ type: "status", line: statusLine });
@@ -583,13 +614,18 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
         if (line.includes('"type":"tool_call"') || line.includes('"type": "tool_call"')) {
           hadToolActivity = true;
           let subtype = "?";
+          let toolName = "?";
           try {
             const ev = JSON.parse(line);
-            if (ev && ev.type === "tool_call") subtype = ev.subtype ?? "?";
+            if (ev && ev.type === "tool_call") {
+              subtype = ev.subtype ?? "?";
+              toolName = ev.tool_call && typeof ev.tool_call === "object" ? Object.keys(ev.tool_call)[0] ?? "?" : "?";
+            }
           } catch {
             const m = line.match(/"subtype"\s*:\s*"([^"]+)"/);
             if (m) subtype = m[1];
           }
+          if (!isCursorReadOnlyToolCall(toolName)) hadMutatingToolActivity = true;
           emit({ type: "status", line: t("runner.tool_call", { subtype }) });
         } else if (isLikelyBase64(line)) {
           emit({ type: "status", line: t("runner.base64_data", { len: line.length }) });
@@ -624,44 +660,55 @@ 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 (hadToolActivity) return false;
-        if (!isCursorQuotaError(errorText)) return false;
-        const errorCategory = classifyCursorApiKeyLimitError(errorText);
-        const cooldownMinutes = cursorApiKeyCooldownMinutes(cursorBaseEnv, errorText);
-        markCursorApiKeyLaneBlocked(
-          cursorSelection,
-          cursorModelSelection.lane,
-          cooldownMinutes,
-          errorText,
-          Date.now(),
-          {
-            modelId: cursorModelSelection.modelId,
-            modelName: cursorModelSelection.modelName,
-          },
-        );
+      const retryCursorFailure = (errorText) => {
+        const quotaFailure = isCursorQuotaError(errorText);
+        const loopingFailure = isCursorAgentLoopingError(errorText);
+        if (!quotaFailure && !loopingFailure) return false;
+        if (quotaFailure && hadToolActivity) return false;
+        if (loopingFailure && hadMutatingToolActivity) return false;
+        const errorCategory = quotaFailure ? classifyCursorApiKeyLimitError(errorText) : "agent_looping";
+        if (quotaFailure && cursorSelection) {
+          const cooldownMinutes = cursorApiKeyCooldownMinutes(cursorBaseEnv, errorText);
+          markCursorApiKeyLaneBlocked(
+            cursorSelection,
+            cursorModelSelection.lane,
+            cooldownMinutes,
+            errorText,
+            Date.now(),
+            {
+              modelId: cursorModelSelection.modelId,
+              modelName: cursorModelSelection.modelName,
+            },
+          );
+        }
         const canTryComposer = !hasExplicitModel
           && cursorModelSelection.lane === "auto"
-          && errorCategory === "explicit_limit"
-          && isCursorAutoFallbackEligible(errorText);
-        const hasNextKey = cursorAttemptIndex < cursorAttempts.length - 1;
+          && (
+            loopingFailure
+            || (errorCategory === "explicit_limit" && isCursorAutoFallbackEligible(errorText))
+          );
+        const hasNextKey = quotaFailure && Boolean(cursorSelection) && cursorAttemptIndex < cursorAttempts.length - 1;
         if (!canTryComposer && !hasNextKey) return false;
 
         const retry = async () => {
           if (canTryComposer) {
+            const authLabel = cursorSelection
+              ? `API Key ${cursorApiKeyLabel(cursorSelection)}`
+              : "login session";
             emit({
               type: "status",
-              line: `Cursor Auto on API Key ${cursorApiKeyLabel(cursorSelection)} is out of usage; discovering Composer fallback...`,
+              line: loopingFailure
+                ? `Cursor Auto on ${authLabel} entered a response loop; discovering Composer fallback...`
+                : `Cursor Auto on ${authLabel} is out of usage; discovering Composer fallback...`,
             });
             const catalog = await discoverCursorModels({
-              keyId: cursorSelection.id,
+              keyId: cursorSelection?.id || `login:${cursorBaseEnv.AGENTFLOW_USER_ID || "default"}`,
               cwd: ws,
               command: agentCmd,
               env: childEnv(options, cursorApiKeyEnv(cursorSelection)),
             });
             if (catalog.fallbackModel) {
-              recordCursorApiKeyFallbackModel(cursorSelection, catalog.fallbackModel);
+              if (cursorSelection) recordCursorApiKeyFallbackModel(cursorSelection, catalog.fallbackModel);
               const fallbackSelection = {
                 lane: "fallback",
                 modelId: catalog.fallbackModel.id,
@@ -677,6 +724,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
                 stream: "runner",
                 eventType: "model_fallback",
                 text: `auto -> ${fallbackSelection.modelId}`,
+                reason: loopingFailure ? "agent_looping" : "usage_limit",
               });
               const fallback = runCursorAgentWithPrompt(
                 cliWorkspace,
@@ -705,7 +753,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
             await next.finished;
             return;
           }
-          throw new Error(errorText || "Cursor API Key reached its limit.");
+          throw annotateFailure(new Error(errorText || (loopingFailure ? "Cursor Agent entered a response loop." : "Cursor API Key reached its limit.")));
         };
         retry().then(resolve).catch(reject);
         return true;
@@ -713,9 +761,9 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
       if (code !== 0 && lastResult == null) {
         const stderr = Buffer.concat(stderrChunks).toString("utf-8");
         const stderrTail = stderr ? stderr.trim().slice(-1200) : "";
-        if (retryCursorQuota(stderrTail)) return;
+        if (retryCursorFailure(stderrTail)) return;
         const stderrSummary = summarizeCursorStderr(stderr);
-        const err = new Error(`Cursor CLI exited ${code}. ${stderrSummary || "No result event received."}`);
+        const err = annotateFailure(new Error(`Cursor CLI exited ${code}. ${stderrSummary || "No result event received."}`));
         err.cursorStderrTail = stderrTail;
         emit({ type: "status", line: truncateComposerLine(err.message) });
         reject(err);
@@ -723,9 +771,9 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
       }
       if (hadError || (lastResult && lastResult.is_error)) {
         const msg = cursorResultErrorText(lastResult) || "Agent reported error.";
-        if (retryCursorQuota(msg)) return;
+        if (retryCursorFailure(msg)) return;
         emit({ type: "status", line: truncateComposerLine(msg) });
-        reject(new Error(msg));
+        reject(annotateFailure(new Error(msg)));
         return;
       }
       if (cursorSelection) clearCursorApiKeyLaneCooldown(cursorSelection, cursorModelSelection.lane);

package/bin/lib/builtin-node-review.mjs

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as acornParse } from "acorn";
+
+import { PACKAGE_ROOT } from "./paths.mjs";
+
+const WORKSPACE_RUNTIME_PATH = "bin/lib/workspace-server.mjs";
+
+// Only modules explicitly listed here are exposed in full. The runtime adapter is
+// extracted from workspace-server.mjs so the review always follows the code that
+// actually dispatches the built-in node without exposing the whole server file.
+const BUILTIN_NODE_IMPLEMENTATION_FILES = new Map([
+  ["tool_wecom_send_group_markdown", ["bin/lib/wecom.mjs"]],
+  ["tool_wecom_send_app_markdown", ["bin/lib/wecom.mjs"]],
+]);
+
+const sourceCache = new Map();
+let runtimeAstCache = null;
+
+function readPackageSource(relativePath) {
+  const normalized = String(relativePath || "").replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalized || normalized.includes("..")) return "";
+  if (sourceCache.has(normalized)) return sourceCache.get(normalized);
+  const absolutePath = path.join(PACKAGE_ROOT, normalized);
+  let source = "";
+  try {
+    if (fs.statSync(absolutePath).isFile()) source = fs.readFileSync(absolutePath, "utf8").replace(/\r\n/g, "\n");
+  } catch {}
+  sourceCache.set(normalized, source);
+  return source;
+}
+
+function walkAst(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (typeof node.type === "string") visit(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (["start", "end", "loc", "type"].includes(key)) continue;
+    if (Array.isArray(value)) {
+      for (const child of value) walkAst(child, visit);
+    } else if (value && typeof value === "object") {
+      walkAst(value, visit);
+    }
+  }
+}
+
+function astContainsString(node, expected) {
+  let found = false;
+  walkAst(node, (candidate) => {
+    if (candidate.type === "Literal" && candidate.value === expected) found = true;
+  });
+  return found;
+}
+
+function runtimeAst() {
+  const source = readPackageSource(WORKSPACE_RUNTIME_PATH);
+  if (!source) return { source: "", ast: null };
+  if (runtimeAstCache?.source === source) return runtimeAstCache;
+  let ast = null;
+  try {
+    ast = acornParse(source, { ecmaVersion: "latest", sourceType: "module", allowHashBang: true });
+  } catch {}
+  runtimeAstCache = { source, ast };
+  return runtimeAstCache;
+}
+
+function runtimeAdapterSource(definitionId) {
+  const { source, ast } = runtimeAst();
+  if (!source || !ast) return "";
+  const matches = [];
+  walkAst(ast, (node) => {
+    if (node.type !== "IfStatement" || !astContainsString(node.test, definitionId)) return;
+    matches.push(source.slice(node.start, node.end).trim());
+  });
+  return matches.join("\n\n");
+}
+
+export function builtinNodeReviewSources(definitionId = "") {
+  const id = String(definitionId || "").trim();
+  if (!id) return [];
+  const sources = [];
+  const adapter = runtimeAdapterSource(id);
+  if (adapter) {
+    sources.push({
+      sourcePath: `builtin/${id}/runtime-adapter.mjs`,
+      title: "内置运行适配器",
+      kind: "builtin-adapter",
+      content: adapter,
+    });
+  }
+  for (const relativePath of BUILTIN_NODE_IMPLEMENTATION_FILES.get(id) || []) {
+    const content = readPackageSource(relativePath);
+    if (!content) continue;
+    sources.push({
+      sourcePath: relativePath,
+      title: `内置实现 · ${path.basename(relativePath)}`,
+      kind: "builtin-implementation",
+      content,
+    });
+  }
+  return sources;
+}

package/bin/lib/repository-index.mjs

@@ -20,7 +20,7 @@ import {
   workspaceRunPlan,
 } from "./workspace-server.mjs";
 
-const REPOSITORY_INDEX_VERSION = 1;
+const REPOSITORY_INDEX_VERSION = 2;
 const REPOSITORY_INDEX_FILENAME = "repository-index.json";
 const REPOSITORY_INDEX_MAX_AGE_MS = 5 * 60 * 1000;
 const memoryIndexes = new Map();
@@ -167,10 +167,12 @@ function scanProjectFlows(workspaceRoot, usageStats) {
   const appendFlow = (ownerId, flow, flowSource = "user", workspaceId = "") => {
     if (!ownerId || flow.archived || !flow.path) return;
     let stable;
+    let draftGraph;
     let graph;
     try {
+      draftGraph = readWorkspaceGraph(flow.path, workspaceRoot).graph;
       stable = readWorkspaceStableRelease(flow.path, workspaceRoot);
-      graph = stable?.graph || readWorkspaceGraph(flow.path, workspaceRoot).graph;
+      graph = stable?.graph || draftGraph;
     } catch {
       return;
     }
@@ -181,6 +183,13 @@ function scanProjectFlows(workspaceRoot, usageStats) {
       const baseId = projectFlowRepositoryId(ownerId, flowSource, flow.id);
       const id = runnableEntries.length === 1 ? baseId : `${baseId}:${runnable.entryId}`;
       const version = stable?.release?.id || `current-${workspaceDesignRevision(graph).slice(0, 12)}`;
+      const releaseState = stable?.release?.id ? "stable" : "draft";
+      const draftRevision = workspaceDesignRevision(draftGraph);
+      const stableRevisions = new Set([
+        stable?.release?.designRevision || "",
+        stable?.graph ? workspaceDesignRevision(stable.graph) : "",
+      ].filter(Boolean));
+      const hasUnpublishedChanges = Boolean(stable?.release?.id && !stableRevisions.has(draftRevision));
       const rawEntryLabel = String(runnable.entry?.label || "").trim();
       const genericLabel = ["", "Run", "Scheduled Run", "运行", "定时运行"].includes(rawEntryLabel);
       const exactOwner = flowSource === "user" ? ownerId : "";
@@ -200,6 +209,9 @@ function scanProjectFlows(workspaceRoot, usageStats) {
         description: flow.description || "",
         version,
         versionLabel: stable?.release?.id ? `Stable ${stable.release.id}` : "当前版本",
+        releaseState,
+        stableReleaseId: stable?.release?.id || "",
+        hasUnpublishedChanges,
         runMode: runnable.runMode,
         runModeLabel: runnable.runMode === "scheduled" ? "定时运行" : "手动运行",
         ownerUserId: ownerId,

package/bin/lib/workspace-routes.mjs

@@ -27,6 +27,7 @@ import {
   writeAiExplorationMaterialization,
 } from "./ai-exploration.mjs";
 import { buildSkillCompactInjectionBlock, loadResourcesForSkillKeys } from "./composer-skill-router.mjs";
+import { builtinNodeReviewSources } from "./builtin-node-review.mjs";
 import { execFileBuffered } from "./exec-buffered.mjs";
 import { runGit } from "./git-worktree.mjs";
 import {
@@ -393,6 +394,10 @@ function workspaceNodeReviewSnapshot(workspaceRoot, flowRoot, graph, nodeId, use
     }));
   }
 
+  if (!marketplaceRef.startsWith("marketplace:")) {
+    sources.push(...builtinNodeReviewSources(definitionId).map((source) => workspaceNodeReviewSource(source)));
+  }
+
   for (const [ref, kind] of [[instance.scriptRef, "script"], [instance.implementationRef, "implementation"]]) {
     const source = workspaceNodeReviewFlowFile(flowRoot, ref, kind);
     if (source?.error) errors.push(source.error);
@@ -1102,7 +1107,7 @@ function listRunnableProjectMarketplaceFlows(workspaceRoot, userCtx = {}, scope
 }
 
 function publicProjectFlowMarketplaceResource(resource) {
-  const { _graph, _flowRoot, ...publicResource } = resource;
+  const { _graph, _flowRoot, flowRoot, ...publicResource } = resource;
   return publicResource;
 }
 
@@ -1258,6 +1263,8 @@ async function workspaceRoutes(req, res, ctx) {
         const kind = String(url.searchParams.get("kind") || "flow").trim();
         const requestedScope = String(url.searchParams.get("scope") || "all").trim();
         const scope = ["all", "owned", "installed"].includes(requestedScope) ? requestedScope : "all";
+        const requestedReleaseState = String(url.searchParams.get("releaseState") || "all").trim().toLowerCase();
+        const releaseState = ["all", "stable", "draft"].includes(requestedReleaseState) ? requestedReleaseState : "all";
         const marketplaceScope = scope === "owned" ? "owned" : "all";
         const queryText = String(url.searchParams.get("q") || "").trim().toLowerCase();
         if (kind === "node") {
@@ -1320,6 +1327,7 @@ async function workspaceRoutes(req, res, ctx) {
         const items = sortMarketplaceResources(
           projectFlows
             .filter((item) => scope !== "installed" || item.installed)
+            .filter((item) => releaseState === "all" || item.releaseState === releaseState)
             .filter((item) => marketplaceResourceMatches(item, queryText)),
         );
         const page = paginateMarketplaceResources(items, url);
@@ -1327,6 +1335,7 @@ async function workspaceRoutes(req, res, ctx) {
         json(res, 200, {
           kind,
           scope,
+          releaseState,
           sort: "useCount",
           order: "desc",
           ...page,
@@ -1568,7 +1577,11 @@ async function workspaceRoutes(req, res, ctx) {
           marketplaceAction: action,
           marketplaceInstallFlowId: resource.installFlowId || resource.liveFlowId || resource.definitionId || id,
         });
-        if (previewKind === "node") previewParams.set("focusNodeId", "node_preview");
+        if (previewKind === "node") {
+          previewParams.set("focusNodeId", "node_preview");
+        } else if (projectFlow && resource.liveEntryId) {
+          previewParams.set("focusNodeId", resource.liveEntryId);
+        }
         if (action === "open-source") {
           previewParams.set("marketplaceTargetFlowId", resource.liveFlowId || resource.definitionId || "");
           previewParams.set("marketplaceTargetFlowSource", resource.liveFlowSource || "user");
@@ -3353,6 +3366,7 @@ async function workspaceRoutes(req, res, ctx) {
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId,
           flowSource: flowSource || "user",
+          adminOwnerId: url.searchParams.get("adminOwnerId") || "",
           archived: url.searchParams.get("archived") === "1",
         }, userCtx);
         if (scoped.error) {
@@ -3388,6 +3402,7 @@ async function workspaceRoutes(req, res, ctx) {
         const scoped = resolveWorkspaceScopeRoot(root, {
           flowId,
           flowSource,
+          adminOwnerId: url.searchParams.get("adminOwnerId") || "",
           archived: url.searchParams.get("archived") === "1",
         }, userCtx);
         if (scoped.error) {

package/bin/lib/workspace-run-logs.mjs

@@ -7,6 +7,11 @@ import { runLedgerId } from "./run-ledger.mjs";
 const MAX_EVENT_TEXT_CHARS = 20_000;
 const MAX_INDEX_RECORDS = 10_000;
 const SECRET_KEY_RE = /(token|password|passwd|secret|webhook|authorization|api[_-]?key|access[_-]?key)/i;
+const SECRET_TEXT_PATTERNS = [
+  [/\b(Bearer)\s+[A-Za-z0-9._~+/=-]+/gi, "$1 ***"],
+  [/((?:token|password|passwd|secret|authorization|api[_-]?key|access[_-]?key)\s*[=:]\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi, "$1***"],
+  [/(["'](?:token|password|passwd|secret|authorization|api[_-]?key|access[_-]?key)["']\s*:\s*)("[^"]*"|'[^']*')/gi, "$1\"***\""],
+];
 
 function safeSegment(value, fallback = "run") {
   return String(value || fallback)
@@ -34,9 +39,15 @@ function truncateText(value) {
   return `${text.slice(0, MAX_EVENT_TEXT_CHARS)}\n... [truncated ${text.length - MAX_EVENT_TEXT_CHARS} chars]`;
 }
 
+function redactText(value) {
+  let text = truncateText(value);
+  for (const [pattern, replacement] of SECRET_TEXT_PATTERNS) text = text.replace(pattern, replacement);
+  return text;
+}
+
 function redact(value, depth = 0) {
   if (depth > 8) return "[MaxDepth]";
-  if (typeof value === "string") return truncateText(value);
+  if (typeof value === "string") return redactText(value);
   if (value == null || typeof value === "number" || typeof value === "boolean") return value;
   if (Array.isArray(value)) return value.slice(0, 200).map((item) => redact(item, depth + 1));
   if (typeof value === "object") {