@fieldwangai/agentflow 0.1.86 → 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());
@@ -2300,13 +2397,27 @@ function normalizeDisplayShareNodeIds(ids, graph) {
     const id = String(rawId || "").trim();
     if (!id || seen.has(id)) continue;
     const instance = instances[id];
-    if (!workspaceDisplayKind(instance?.definitionId)) continue;
+    if (!workspaceDisplayKindFromInstance(instance)) continue;
     seen.add(id);
     out.push(id);
   }
   return out;
 }
 
+function workspaceDisplayContentFromInstance(instance, kind = "") {
+  const slots = [...(Array.isArray(instance?.input) ? instance.input : []), ...(Array.isArray(instance?.output) ? instance.output : [])];
+  const primaryName = kind === "image" ? "src" : "content";
+  const slotText = (slot) => workspaceSlotValue(slot);
+  const hasSlotText = (slot) => slotText(slot).trim();
+  const contentSlot =
+    slots.find((slot) => String(slot?.name || "") === primaryName && hasSlotText(slot)) ||
+    slots.find((slot) => String(slot?.name || "") === "result" && hasSlotText(slot)) ||
+    slots.find((slot) => String(slot?.name || "") === "filePath" && hasSlotText(slot)) ||
+    slots.find((slot) => String(slot?.type || "") === "text" && hasSlotText(slot));
+  const slotContent = contentSlot ? slotText(contentSlot) : "";
+  return String(isWorkspaceOneClickTaskDefinitionId(instance?.definitionId) ? slotContent : (instance?.body || slotContent));
+}
+
 function normalizeDisplayShareLayout(layout, fallback = "canvas") {
   const text = String(layout || "").trim();
   return ["canvas", "gallery", "slides", "document", "single"].includes(text) ? text : fallback;
@@ -2518,8 +2629,8 @@ function publicDisplayPayloadFromShare(root, share) {
   const nodes = nodeIds.map((id) => {
     const instance = instances[id] || {};
     const definitionId = String(instance.definitionId || "");
-    const kind = workspaceDisplayKind(definitionId);
-    const rawBody = String(instance.body || "");
+    const kind = workspaceDisplayKindFromInstance(instance);
+    const rawBody = workspaceDisplayContentFromInstance(instance, kind);
     const filePath = workspaceDisplayTextFilePath(rawBody, kind);
     let body = rawBody;
     if (filePath) {
@@ -2811,6 +2922,20 @@ function buildWorkspaceGeneratePrompt(payload) {
     ? payload.selectedNodeIds.map((id) => String(id || "").trim()).filter(Boolean)
     : [];
   const skillsBlock = typeof payload?.skillsBlock === "string" ? payload.skillsBlock.trim() : "";
+  const history = Array.isArray(payload?.messages) ? payload.messages : [];
+  const historyBlock = history
+    .slice(-16)
+    .map((msg) => {
+      const text = String(msg?.text || "").trim();
+      if (!text) return "";
+      const kind = String(msg?.kind || "").trim();
+      if (kind === "raw" || kind === "prompt" || kind === "thinking") return "";
+      const role = msg?.role === "user" ? "user" : (msg?.error ? "error" : "assistant");
+      if (kind === "run-summary" || kind === "activity") return `context: ${text}`;
+      return `${role}: ${text}`;
+    })
+    .filter(Boolean)
+    .join("\n\n");
   const contexts = Array.isArray(payload?.contexts) ? payload.contexts : [];
   const contextBlocks = contexts
     .map((ctx, idx) => {
@@ -2867,6 +2992,7 @@ function buildWorkspaceGeneratePrompt(payload) {
     skillsBlock ? `\n## Selected Skills\n\n${skillsBlock}` : "",
     kindInstruction,
     contextBlocks ? `\n## 上下文\n\n${contextBlocks}` : "",
+    historyBlock ? `\n## 对话历史\n\n${historyBlock}` : "",
     `\n## 用户 prompt\n\n${userPrompt}`,
   ].filter(Boolean).join("\n");
 }
@@ -3462,6 +3588,14 @@ function workspaceDisplayKind(definitionId) {
   return "";
 }
 
+function workspaceDisplayKindFromInstance(instance) {
+  const direct = workspaceDisplayKind(instance?.definitionId);
+  if (direct) return direct;
+  if (!isWorkspaceOneClickTaskDefinitionId(instance?.definitionId)) return "";
+  if (!workspaceDisplayContentFromInstance(instance, workspaceContextRunDisplayKind(instance)).trim()) return "";
+  return workspaceContextRunDisplayKind(instance);
+}
+
 function workspaceDisplayTextFilePath(value, kind = "") {
   const text = String(value || "").trim();
   if (!text || text.length > 260) return "";
@@ -7630,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),
@@ -7643,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, {