@fieldwangai/agentflow 0.1.105 → 0.1.107

package/bin/lib/ui-server.mjs

@@ -152,11 +152,24 @@ import {
   addPrdWorkflowCollaborationMember,
   ensurePrdWorkflowCollaboration,
   getPrdWorkflowCollaborationById,
+  getPrdWorkflowCollaborationByShareToken,
   getPrdWorkflowCollaborationForUser,
+  ensurePrdWorkflowShareLink,
   prdWorkflowCollaborationAccess,
   prdWorkflowCollaborationSummary,
   removePrdWorkflowCollaborationMember,
+  revokePrdWorkflowShareLink,
 } from "./prd-workflow-collaboration.mjs";
+import {
+  legacyOverallToGlobalState,
+  materializeWorkflowGlobalState,
+  mergeWorkflowArtifactLists,
+  mergeWorkflowArtifacts,
+  mergeWorkflowGlobalState,
+  normalizeWorkflowReference,
+  normalizeWorkflowReport,
+  workflowRuntimeRevision,
+} from "./workflow-report.mjs";
 
 const MIME = {
   ".html": "text/html; charset=utf-8",
@@ -173,6 +186,11 @@ const MIME = {
   ".svg": "image/svg+xml",
   ".ico": "image/x-icon",
 };
+const ADMIN_ONLY_USER_ENV_KEYS = new Set([
+  "CURSOR_API_KEYS",
+  "AGENTFLOW_CURSOR_API_KEY_COOLDOWN_MINUTES",
+  "CURSOR_API_KEY_COOLDOWN_MINUTES",
+]);
 
 const UI_SERVER_STARTED_AT = new Date().toISOString();
 const UI_SERVER_APP_VERSION = (() => {
@@ -3227,6 +3245,25 @@ function prdWorkflowCollaborationSummaryWithUsers(record, userId) {
   };
 }
 
+function prdWorkflowShareLinkSummary(record, shareToken, publicBaseUrl, userId = "") {
+  const token = String(shareToken || record?.shareToken || "").trim();
+  if (!record || !token) return null;
+  const query = new URLSearchParams({
+    view: "workflow",
+    tapdId: String(record.tapdId || ""),
+    workflowShare: token,
+  });
+  const base = String(publicBaseUrl || "").replace(/\/+$/, "");
+  return {
+    tapdId: String(record.tapdId || ""),
+    url: `${base}/workspace?${query.toString()}`,
+    active: true,
+    readOnly: true,
+    createdAt: record.shareCreatedAt || "",
+    canManage: String(record.ownerId || "") === String(userId || "").trim().toLowerCase(),
+  };
+}
+
 function workspaceConversationsPath(scopedRoot) {
   return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "conversations.json");
 }
@@ -4065,9 +4102,50 @@ function workspaceSafeNodeOutputRelPath(value) {
   return clean;
 }
 
-function workspaceDescribeNodeOutputsDir(nodeRunDir, maxEntries = 30) {
-  const outputsDir = path.resolve(nodeRunDir || "", "outputs");
-  if (!nodeRunDir || !fs.existsSync(outputsDir)) return "Current node outputs directory is missing.";
+function workspaceResolveOutputChild(rootDir, relativePath = "") {
+  const root = path.resolve(rootDir || "");
+  if (!rootDir || !root) return "";
+  const parts = String(relativePath || "").split("/").filter(Boolean);
+  const abs = path.resolve(root, ...parts);
+  const rootWithSep = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
+  return abs === root || abs.startsWith(rootWithSep) ? abs : "";
+}
+
+function workspaceNodeOutputSuffix(relPath) {
+  const clean = workspaceSafeNodeOutputRelPath(relPath);
+  return clean ? clean.slice("outputs/".length).replace(/^\/+/, "") : "";
+}
+
+function workspaceNodeOutputWritePath(runPackage, relPath) {
+  const clean = workspaceSafeNodeOutputRelPath(relPath);
+  if (!clean) return "";
+  const suffix = workspaceNodeOutputSuffix(clean);
+  if (runPackage?.directWorkspaceOutputs && runPackage?.outputsDir) {
+    return workspaceResolveOutputChild(runPackage.outputsDir, suffix);
+  }
+  return workspaceResolveOutputChild(runPackage?.nodeRunDir, clean);
+}
+
+function workspaceNodeOutputCandidates(runPackage, relPath) {
+  const clean = workspaceSafeNodeOutputRelPath(relPath);
+  if (!clean) return [];
+  const suffix = workspaceNodeOutputSuffix(clean);
+  const direct = runPackage?.outputsDir
+    ? workspaceResolveOutputChild(runPackage.outputsDir, suffix)
+    : "";
+  const legacy = runPackage?.nodeRunDir
+    ? workspaceResolveOutputChild(runPackage.nodeRunDir, clean)
+    : "";
+  const ordered = runPackage?.directWorkspaceOutputs ? [direct, legacy] : [legacy, direct];
+  return ordered.filter((candidate, index, list) => candidate && list.indexOf(candidate) === index);
+}
+
+function workspaceDescribeNodeOutputsDir(runPackage, maxEntries = 30) {
+  const outputDirs = [
+    runPackage?.outputsDir,
+    runPackage?.nodeRunDir ? path.resolve(runPackage.nodeRunDir, "outputs") : "",
+  ].filter((dir, index, list) => dir && list.indexOf(dir) === index && fs.existsSync(dir));
+  if (!outputDirs.length) return "Current node outputs directory is missing.";
   const entries = [];
   const walk = (dir, rel = "") => {
     if (entries.length >= maxEntries) return;
@@ -4084,7 +4162,7 @@ function workspaceDescribeNodeOutputsDir(nodeRunDir, maxEntries = 30) {
       if (child.isDirectory()) walk(path.join(dir, child.name), childRel);
     }
   };
-  walk(outputsDir);
+  for (const outputDir of outputDirs) walk(outputDir);
   if (!entries.length) return "Current node outputs directory is empty.";
   const suffix = entries.length >= maxEntries ? `\n...showing first ${maxEntries} entries` : "";
   return `Current node outputs entries:\n${entries.map((entry) => `- outputs/${entry}`).join("\n")}${suffix}`;
@@ -4097,29 +4175,31 @@ function workspacePublishNodeOutputFile(runPackage, relPath) {
   const nodeRunDir = path.resolve(runPackage?.nodeRunDir || "");
   const workspaceOutputsDir = path.resolve(runPackage?.workspaceOutputsDir || "");
   if (!nodeRunDir || !workspaceOutputsDir) return clean;
-  const src = path.resolve(nodeRunDir, clean);
-  const nodeRootWithSep = nodeRunDir.endsWith(path.sep) ? nodeRunDir : `${nodeRunDir}${path.sep}`;
-  if (src !== nodeRunDir && !src.startsWith(nodeRootWithSep)) {
-    throw new Error(`Invalid node output path: ${clean}`);
-  }
-  if (!fs.existsSync(src) || !fs.statSync(src).isFile()) {
+  const src = workspaceNodeOutputCandidates(runPackage, clean)
+    .find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+  if (!src) {
     throw new Error(
       `Agent returned resultFile but did not create it under this node's outputs: ${clean}\n` +
-      `Expected file: ${src}\n` +
-      `${workspaceDescribeNodeOutputsDir(nodeRunDir)}\n` +
-      `Write outputs using a relative path from the node cwd, or use AGENTFLOW_OUTPUTS_DIR.`
+      `Expected file: ${workspaceNodeOutputWritePath(runPackage, clean)}\n` +
+      `${workspaceDescribeNodeOutputsDir(runPackage)}\n` +
+      `Write downloadable files to the absolute AGENTFLOW_OUTPUTS_DIR path.`
     );
   }
   const nodePart = workspaceSanitizeTmpSegment(runPackage?.nodeId || "node", "node");
-  const destRel = clean.slice("outputs/".length).replace(/^\/+/, "");
-  const publishedRel = path.posix.join("outputs", nodePart, ...destRel.split("/").filter(Boolean));
-  const dest = path.resolve(workspaceOutputsDir, nodePart, ...destRel.split("/").filter(Boolean));
+  const destRel = workspaceNodeOutputSuffix(clean);
+  const publishedBase = String(runPackage?.outputsRel || "").trim() || path.posix.join("outputs", nodePart);
+  const publishedRel = path.posix.join(publishedBase, ...destRel.split("/").filter(Boolean));
+  const dest = runPackage?.directWorkspaceOutputs && runPackage?.outputsDir
+    ? workspaceResolveOutputChild(runPackage.outputsDir, destRel)
+    : path.resolve(workspaceOutputsDir, nodePart, ...destRel.split("/").filter(Boolean));
   const workspaceOutputsWithSep = workspaceOutputsDir.endsWith(path.sep) ? workspaceOutputsDir : `${workspaceOutputsDir}${path.sep}`;
   if (dest !== workspaceOutputsDir && !dest.startsWith(workspaceOutputsWithSep)) {
     throw new Error(`Invalid workspace output path: ${clean}`);
   }
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-  fs.copyFileSync(src, dest);
+  if (src !== dest) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+  }
   return publishedRel;
 }
 
@@ -4130,16 +4210,15 @@ export function workspaceMaterializeAgentResultFile(structured, runPackage) {
   const declared = workspaceSafeNodeOutputRelPath(rawDeclared);
   if (rawDeclared && !declared) return structured;
   const relPath = declared || configured;
-  const abs = path.resolve(runPackage.nodeRunDir || "", relPath);
-  const nodeRunDir = path.resolve(runPackage.nodeRunDir || "");
-  const nodeRootWithSep = nodeRunDir.endsWith(path.sep) ? nodeRunDir : `${nodeRunDir}${path.sep}`;
-  if (!nodeRunDir || (abs !== nodeRunDir && !abs.startsWith(nodeRootWithSep))) return structured;
+  const abs = workspaceNodeOutputWritePath(runPackage, relPath);
+  if (!abs) return structured;
 
   const explicitInlineResult = structured.parsed && typeof structured.parsed === "object"
     ? String(structured.parsed.result ?? "")
     : "";
   const content = declared ? explicitInlineResult : String(structured.result ?? "");
-  let primaryReady = fs.existsSync(abs) && fs.statSync(abs).isFile();
+  let primaryReady = workspaceNodeOutputCandidates(runPackage, relPath)
+    .some((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
   if (!primaryReady && content.trim()) {
     fs.mkdirSync(path.dirname(abs), { recursive: true });
     const tmp = path.join(path.dirname(abs), `.${path.basename(abs)}.${process.pid}.${Date.now()}.tmp`);
@@ -4164,8 +4243,8 @@ export function workspaceMaterializeAgentResultFile(structured, runPackage) {
     if (!outputContent.trim()) continue;
     const outputRel = workspaceSafeNodeOutputRelPath(configuredRel);
     if (!outputRel) continue;
-    const outputAbs = path.resolve(nodeRunDir, outputRel);
-    if (outputAbs !== nodeRunDir && !outputAbs.startsWith(nodeRootWithSep)) continue;
+    const outputAbs = workspaceNodeOutputWritePath(runPackage, outputRel);
+    if (!outputAbs) continue;
     fs.mkdirSync(path.dirname(outputAbs), { recursive: true });
     fs.writeFileSync(outputAbs, outputContent, "utf-8");
     delete outParams[name];
@@ -4182,18 +4261,73 @@ export function workspaceMaterializeAgentResultFile(structured, runPackage) {
   };
 }
 
+function workspaceCollectNodeOutputFiles(runPackage, maxFiles = 500) {
+  const roots = [
+    runPackage?.outputsDir,
+    runPackage?.nodeRunDir ? path.resolve(runPackage.nodeRunDir, "outputs") : "",
+  ].filter((dir, index, list) => dir && list.indexOf(dir) === index && fs.existsSync(dir));
+  const relativeFiles = new Set();
+  const walk = (root, dir, depth = 0) => {
+    if (depth > 12 || relativeFiles.size >= maxFiles) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (relativeFiles.size >= maxFiles) break;
+      if (entry.isSymbolicLink()) continue;
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(root, abs, depth + 1);
+      } else if (entry.isFile()) {
+        relativeFiles.add(path.relative(root, abs).replace(/\\/g, "/"));
+      }
+    }
+  };
+  for (const root of roots) walk(root, root);
+
+  const outputFiles = [];
+  for (const relativePath of relativeFiles) {
+    const publishedPath = workspacePublishNodeOutputFile(runPackage, `outputs/${relativePath}`);
+    if (!publishedPath) continue;
+    const publishedAbs = workspaceResolveOutputChild(
+      runPackage.workspaceOutputsDir,
+      publishedPath.slice("outputs/".length),
+    );
+    let size = 0;
+    try {
+      size = publishedAbs ? fs.statSync(publishedAbs).size : 0;
+    } catch {}
+    outputFiles.push({ path: publishedPath, name: path.posix.basename(publishedPath), size });
+  }
+  outputFiles.sort((a, b) => a.path.localeCompare(b.path));
+  return outputFiles;
+}
+
 export function workspacePublishAgentOutputFiles(structured, runPackage) {
-  if (!structured?.structured || !runPackage) return structured;
-  const resultFile = workspacePublishNodeOutputFile(runPackage, structured.resultFile);
-  const outParams = { ...(structured.outParams || {}) };
+  if (!runPackage) return structured;
+  const base = structured && typeof structured === "object" ? structured : {};
+  const resultFile = base.structured
+    ? workspacePublishNodeOutputFile(runPackage, base.resultFile)
+    : "";
+  const outParams = { ...(base.outParams || {}) };
   for (const [key, value] of Object.entries(outParams)) {
     if (!String(key || "").endsWith("File")) continue;
     const published = workspacePublishNodeOutputFile(runPackage, value);
     if (published) outParams[key] = published;
   }
-  return resultFile || Object.keys(outParams).length
-    ? { ...structured, result: resultFile || structured.result, resultFile: resultFile || structured.resultFile, outParams }
-    : structured;
+  const outputFiles = workspaceCollectNodeOutputFiles(runPackage);
+  return resultFile || Object.keys(outParams).length || outputFiles.length
+    ? {
+        ...base,
+        result: resultFile || base.result,
+        resultFile: resultFile || base.resultFile,
+        outParams,
+        outputFiles,
+      }
+    : base;
 }
 
 function workspaceOutputFieldForSlot(slot, index = 0) {
@@ -4679,6 +4813,7 @@ function workspaceAgentInputBlock(inputValues = {}, inputMounts = {}) {
 function workspaceNodeFileBoundaryBlock(runPackage = {}) {
   const nodeRunDir = String(runPackage?.nodeRunDir || "").trim();
   const nodeTmpDir = String(runPackage?.nodeTmpDir || "").trim();
+  const outputsDir = String(runPackage?.outputsDir || "").trim();
   const outputsRel = String(runPackage?.outputsRel || "outputs").trim() || "outputs";
   if (!nodeRunDir && !nodeTmpDir) return "";
   return [
@@ -4688,7 +4823,9 @@ function workspaceNodeFileBoundaryBlock(runPackage = {}) {
     nodeTmpDir ? `- 临时文件只能写入：\`${nodeTmpDir}\`，也可通过环境变量 \`AGENTFLOW_NODE_TMP_DIR\` 获取。` : "",
     Object.keys(runPackage?.inputMounts || {}).length ? "- 已挂载的输入文件位于本任务 `inputs/`；`inputs/` 只用于读取，正式产物仍写入 `outputs/`。" : "",
     "- 主文本结果和内联额外输出由 AgentFlow 在任务结束后自动写入、发布和清理，无需自行创建结果文件。",
-    `- 任务若必须直接生成二进制或工程文件，只能写入本任务 \`${outputsRel}/\`；可使用 \`AGENTFLOW_OUTPUTS_DIR\` 获取绝对目录。`,
+    outputsDir ? `- 可供用户下载的最终产物目录：\`${outputsDir}\`。这不是临时目录，环境变量 \`AGENTFLOW_OUTPUTS_DIR\` 指向这里。` : "",
+    outputsDir ? `- CSV、图片、压缩包、工程文件等下载产物必须直接写入 \`AGENTFLOW_OUTPUTS_DIR\`，不要写入当前执行目录中的相对 \`outputs/\`。` : "",
+    outputsDir ? `- 该目录中的文件会自动出现在 Workspace Files，对应相对路径为 \`${outputsRel}/\`；回复中引用下载文件时使用这个相对路径。` : "",
     "- 不要在执行目录根部创建 `temp_*`、`_out.json`、`tmp.html` 等临时产物。",
     "- 不要自行删除 run package；AgentFlow 会在运行结束后统一清理。",
   ].filter(Boolean).join("\n");
@@ -5953,14 +6090,20 @@ function workspaceCreateNodeTmpDir(runTmpRoot, nodeId) {
   return dir;
 }
 
-function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, cwd = "", task = "", inputValues = {}, skillsBlock = "", mcpBlock = "", resultFile = "", outParamFiles = {} } = {}) {
+function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, cwd = "", task = "", inputValues = {}, skillsBlock = "", mcpBlock = "", resultFile = "", outParamFiles = {}, durableOutputs = false } = {}) {
   const nodeRunDir = workspaceCreateNodeTmpDir(runTmpRoot, nodeId);
   const nodeTmpDir = path.join(nodeRunDir, "tmp");
-  const outputsDir = path.join(nodeRunDir, "outputs");
+  const legacyOutputsDir = path.join(nodeRunDir, "outputs");
   const workspaceRoot = path.resolve(scopedRoot);
   const workspaceOutputsDir = path.join(workspaceRoot, "outputs");
+  const nodePart = workspaceSanitizeTmpSegment(nodeId || "node", "node");
+  const outputsRel = durableOutputs ? path.posix.join("outputs", nodePart) : "outputs";
+  const outputsDir = durableOutputs ? path.join(workspaceOutputsDir, nodePart) : legacyOutputsDir;
   const resultFileRel = workspaceSafeNodeOutputRelPath(resultFile) || "";
-  const resultFileAbs = resultFileRel ? path.resolve(nodeRunDir, resultFileRel) : "";
+  const resultFileSuffix = workspaceNodeOutputSuffix(resultFileRel);
+  const resultFileAbs = resultFileRel
+    ? workspaceResolveOutputChild(outputsDir, resultFileSuffix)
+    : "";
   const safeOutParamFiles = {};
   for (const [name, rel] of Object.entries(outParamFiles || {})) {
     const cleanName = String(name || "").trim();
@@ -5968,6 +6111,8 @@ function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, cwd = "
     if (cleanName && cleanRel) safeOutParamFiles[cleanName] = cleanRel;
   }
   fs.mkdirSync(nodeTmpDir, { recursive: true });
+  fs.mkdirSync(legacyOutputsDir, { recursive: true });
+  if (durableOutputs) fs.rmSync(outputsDir, { recursive: true, force: true });
   fs.mkdirSync(outputsDir, { recursive: true });
   fs.mkdirSync(workspaceOutputsDir, { recursive: true });
   const manifest = {
@@ -5976,7 +6121,11 @@ function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, cwd = "
     nodeRunDir,
     nodeTmpDir,
     outputsDir,
+    legacyOutputsDir,
+    outputsRel,
+    directWorkspaceOutputs: durableOutputs,
     workspaceRoot,
+    workspaceOutputsDir,
     executionCwd: cwd ? path.resolve(cwd) : workspaceRoot,
     resultFileRel,
     resultFileAbs,
@@ -6001,8 +6150,6 @@ function workspaceCreateNodeRunPackage(runTmpRoot, nodeId, { scopedRoot, cwd = "
   }
   return {
     ...manifest,
-    workspaceOutputsDir,
-    outputsRel: "outputs",
     inputValues: runtimeInputValues,
     inputMounts: materializedInputs.mounts,
   };
@@ -6840,6 +6987,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
         cwd,
         task: String(instance.script || instance.scriptRef || instance.body || "").trim(),
         inputValues,
+        durableOutputs: true,
       });
       const runtimeInputValues = { ...inputValues, ...(runPackage.inputValues || {}) };
       emitTiming(nodeId, "prepare-script", prepareStartedAt, {
@@ -6876,7 +7024,12 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       if (implementationUpdate.changed) graph.instances[nodeId] = implementationUpdate.instance;
       const updatedDisplays = propagateNodeOutputDisplays(nodeId, resultContent);
       if (slotUpdate.changed || implementationUpdate.changed || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
-      emit({ type: "node-done", nodeId, definitionId: defId });
+      emit({
+        type: "node-done",
+        nodeId,
+        definitionId: defId,
+        outputFiles: normalizedAgentOutput.outputFiles || [],
+      });
       continue;
     }
 
@@ -6900,6 +7053,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
       mcpBlock: promptMcpBlock,
       resultFile: resultOutputSpec.resultFile,
       outParamFiles: workspaceOutParamFileSpecs(graph, nodeId),
+      durableOutputs: true,
     });
     const runtimeInputValues = { ...inputValues, ...(runPackage.inputValues || {}) };
     const body = workspaceResolveBodyPlaceholders(instance.body || "", runtimeInputValues).trim();
@@ -6950,6 +7104,7 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
         const handle = startComposerAgent({
           uiWorkspaceRoot: scopedRoot,
           cliWorkspace: runPackage.nodeRunDir,
+          writableDirs: [runPackage.outputsDir],
           prompt,
           modelKey: nodeModelKey,
           agentflowUserId: userCtx.userId || "",
@@ -7039,7 +7194,12 @@ async function runWorkspaceGraph(root, scopedRoot, payload, userCtx = {}, opts =
     }
     const updatedDisplays = propagateNodeOutputDisplays(nodeId, resultContent);
     if (slotUpdate.changed || implementationUpdate.changed || contextRunOutputChanged || updatedDisplays.length) emit({ type: "graph", nodeId, displayNodeIds: updatedDisplays, graph });
-    emit({ type: "node-done", nodeId, definitionId: defId });
+    emit({
+      type: "node-done",
+      nodeId,
+      definitionId: defId,
+      outputFiles: normalizedAgentOutput.outputFiles || [],
+    });
   }
   } finally {
     workspaceCleanupAutoWorktrees(autoCleanupWorktrees, graph, emit);
@@ -7253,14 +7413,22 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
   const flowId = String(params.flowId || "").trim();
   const flowSource = String(params.flowSource || "user").trim() || "user";
   const archived = params.archived === true || params.archived === "1" || params.flowArchived === true;
-  const collaboration = tapdId
+  const shareToken = String(params.workflowShare || params.workflow_share || "").trim();
+  const linkCollaboration = shareToken ? getPrdWorkflowCollaborationByShareToken(shareToken) : null;
+  if (shareToken && (!linkCollaboration || linkCollaboration.tapdId !== tapdId)) {
+    return { error: "Workflow share link is invalid or has been revoked", status: 404 };
+  }
+  const memberCollaboration = tapdId
     ? getPrdWorkflowCollaborationForUser(tapdId, userCtx?.userId)
     : null;
-  const access = prdWorkflowCollaborationAccess(collaboration, userCtx?.userId);
+  const collaboration = linkCollaboration || memberCollaboration;
+  const access = linkCollaboration
+    ? { allowed: true, writable: false, role: "viewer", via: "share-link" }
+    : prdWorkflowCollaborationAccess(collaboration, userCtx?.userId);
   if (collaboration && !access.allowed) {
     return { error: "PRD Workflow collaboration permission denied", status: 403 };
   }
-  if (capability === "write" && collaboration && !access.writable) {
+  if (capability === "write" && (linkCollaboration || (collaboration && !access.writable))) {
     return { error: "PRD Workflow collaboration edit permission denied", status: 403 };
   }
   const ownerId = String(collaboration?.ownerId || userCtx?.userId || "").trim();
@@ -7287,15 +7455,18 @@ function resolvePrdWorkflowScope(workspaceRoot, params = {}, userCtx = {}, capab
     ownerId,
     collaboration,
     collaborationAccess: access,
+    shareToken,
+    sharedByLink: Boolean(linkCollaboration),
     flowId,
     flowSource,
     archived,
   };
 }
 
-function prdWorkflowKey(userCtx = {}, flowSource = "user", flowId = "", tapdId = "") {
+function prdWorkflowKey(userCtx = {}, flowSource = "user", flowId = "", tapdId = "", shareToken = "") {
   const id = String(tapdId || "").trim();
-  const collaboration = getPrdWorkflowCollaborationForUser(id, userCtx?.userId);
+  const collaboration = getPrdWorkflowCollaborationByShareToken(shareToken)
+    || getPrdWorkflowCollaborationForUser(id, userCtx?.userId);
   const actorScope = `user:${String(collaboration?.ownerId || userCtx?.userId || "")}`;
   return [actorScope, id].join("\t");
 }
@@ -8800,6 +8971,19 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
               incomingImplementationMetadata,
             )
           : previousImplementationMetadata;
+      const previousGlobalStatePatch =
+        events[index]?.globalStatePatch || events[index]?.global_state_patch;
+      const incomingGlobalStatePatch =
+        entry?.globalStatePatch || entry?.global_state_patch;
+      const mergedGlobalStatePatch =
+        incomingGlobalStatePatch && typeof incomingGlobalStatePatch === "object" && !Array.isArray(incomingGlobalStatePatch)
+          ? mergeWorkflowGlobalState(
+              previousGlobalStatePatch && typeof previousGlobalStatePatch === "object" && !Array.isArray(previousGlobalStatePatch)
+                ? previousGlobalStatePatch
+                : {},
+              incomingGlobalStatePatch,
+            )
+          : previousGlobalStatePatch;
       const prevArtifact = prdWorkflowRuntimeEventArtifactSignature(events[index]);
       const nextArtifact = prdWorkflowRuntimeEventArtifactSignature(entry);
       artifactConflict = Boolean(prevArtifact && nextArtifact && prevArtifact !== nextArtifact &&
@@ -8815,9 +8999,14 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
         ...events[index],
         ...entry,
         links: prdWorkflowMergeRuntimeEventArrays(events[index].links, entry.links),
-        artifacts: prdWorkflowMergeRuntimeEventArrays(events[index].artifacts, entry.artifacts),
+        artifacts: mergeWorkflowArtifactLists(events[index].artifacts, entry.artifacts, entry.artifactScope || "action"),
         outputs: prdWorkflowMergeRuntimeEventArrays(events[index].outputs, entry.outputs),
         results: prdWorkflowMergeRuntimeEventArrays(events[index].results, entry.results),
+        actionModel: mergeWorkflowGlobalState(events[index].actionModel, entry.actionModel),
+        globalStateRemove: prdWorkflowMergeRuntimeEventArrays(
+          events[index].globalStateRemove || events[index].global_state_remove,
+          entry.globalStateRemove || entry.global_state_remove,
+        ),
         createdAt: events[index].createdAt || entry.createdAt,
         startedAt: events[index].startedAt || entry.startedAt,
         idempotencyHistory: [...new Set(idempotencyHistory)].slice(-50),
@@ -8825,6 +9014,9 @@ function prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, event = {}) {
       if (mergedImplementationMetadata && typeof mergedImplementationMetadata === "object" && !Array.isArray(mergedImplementationMetadata)) {
         events[index].implementationMetadata = mergedImplementationMetadata;
       }
+      if (mergedGlobalStatePatch && typeof mergedGlobalStatePatch === "object" && !Array.isArray(mergedGlobalStatePatch)) {
+        events[index].globalStatePatch = mergedGlobalStatePatch;
+      }
       if (artifactConflict) {
         events[index] = {
           ...events[index],
@@ -8915,7 +9107,7 @@ function prdWorkflowMergeRuntimeEventList(snapshotEvents = [], runtimeEvents = [
         ...out[index],
         ...event,
         links: prdWorkflowMergeRuntimeEventArrays(out[index].links, event.links),
-        artifacts: prdWorkflowMergeRuntimeEventArrays(out[index].artifacts, event.artifacts),
+        artifacts: mergeWorkflowArtifactLists(out[index].artifacts, event.artifacts, event.artifactScope || "action"),
         outputs: prdWorkflowMergeRuntimeEventArrays(out[index].outputs, event.outputs),
         results: prdWorkflowMergeRuntimeEventArrays(out[index].results, event.results),
       };
@@ -9123,13 +9315,55 @@ function prdWorkflowOverallFromEvents(tapdId, snapshot = {}, runtimeEvents = [])
   return prdWorkflowFinalizeOverall(tapdId, overall);
 }
 
+function prdWorkflowEventUpdatesOverall(event) {
+  if (!event || typeof event !== "object" || Array.isArray(event)) return false;
+  return Boolean(
+    event.overallPatch ||
+    event.overall_patch ||
+    event.overallOwnerFromActor === true ||
+    event.overall_owner_from_actor === true ||
+    event.implementationMetadata ||
+    event.implementation_metadata ||
+    (Array.isArray(event.overallRemove) && event.overallRemove.length) ||
+    (Array.isArray(event.overall_remove) && event.overall_remove.length)
+  );
+}
+
+function prdWorkflowGlobalStateFromEvents(tapdId, snapshot = {}, runtimeEvents = []) {
+  let legacyOverall = prdWorkflowOverallFromEvents(tapdId, snapshot, []);
+  let state = materializeWorkflowGlobalState(tapdId, snapshot, [], legacyOverall);
+  const events = [...(Array.isArray(runtimeEvents) ? runtimeEvents : [])].sort((left, right) => {
+    const leftAt = Date.parse(left?.updatedAt || left?.occurredAt || left?.completedAt || left?.createdAt || left?.observedAt || "");
+    const rightAt = Date.parse(right?.updatedAt || right?.occurredAt || right?.completedAt || right?.createdAt || right?.observedAt || "");
+    if (!Number.isFinite(leftAt) && !Number.isFinite(rightAt)) return 0;
+    if (!Number.isFinite(leftAt)) return -1;
+    if (!Number.isFinite(rightAt)) return 1;
+    return leftAt - rightAt;
+  });
+  for (const event of events) {
+    if (prdWorkflowEventUpdatesOverall(event)) {
+      legacyOverall = prdWorkflowOverallFromEvents(tapdId, { overall: legacyOverall }, [event]);
+      state = mergeWorkflowGlobalState(state, legacyOverallToGlobalState(tapdId, legacyOverall));
+    }
+    state = materializeWorkflowGlobalState(tapdId, { globalState: state }, [event], {});
+  }
+  return state;
+}
+
 function prdWorkflowMergeRuntimeEvents(scopedRoot, tapdId, snapshot) {
   const runtime = prdWorkflowReadRuntimeEvents(scopedRoot, tapdId);
   const runtimeEvents = runtime.events;
   const events = prdWorkflowMergeRuntimeEventList(snapshot?.events, runtimeEvents);
+  const overall = prdWorkflowOverallFromEvents(tapdId, snapshot, runtimeEvents);
+  const globalState = prdWorkflowGlobalStateFromEvents(tapdId, snapshot, runtimeEvents);
+  const artifacts = mergeWorkflowArtifacts(snapshot?.artifacts, runtimeEvents);
   return {
     ...snapshot,
-    overall: prdWorkflowOverallFromEvents(tapdId, snapshot, runtimeEvents),
+    workflow: globalState.workflow,
+    overall,
+    globalState,
+    artifacts,
+    runtimeRevision: workflowRuntimeRevision(globalState, artifacts, runtimeEvents),
     runtimeEvents,
     events,
     sources: {
@@ -10500,6 +10734,116 @@ export function startUiServer({
       json(res, 200, { token: getSessionTokenFromRequest(req) || "" });
       return;
     }
+    if (req.method === "GET" && url.pathname === "/api/prd-workflow/share") {
+      const tapdId = String(url.searchParams.get("tapdId") || "").trim();
+      const shareToken = String(url.searchParams.get("workflowShare") || "").trim();
+      if (shareToken) {
+        const record = getPrdWorkflowCollaborationByShareToken(shareToken);
+        if (!record || (tapdId && record.tapdId !== tapdId)) {
+          json(res, 404, { error: "Workflow share link is invalid or has been revoked" });
+          return;
+        }
+        json(res, 200, {
+          ok: true,
+          share: prdWorkflowShareLinkSummary(
+            record,
+            shareToken,
+            serverPublicBaseUrl(req, host, uiPort),
+            userCtx.userId,
+          ),
+        });
+        return;
+      }
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      if (!tapdId) {
+        json(res, 400, { error: "Missing tapdId" });
+        return;
+      }
+      const record = getPrdWorkflowCollaborationForUser(tapdId, userCtx.userId);
+      const role = prdWorkflowCollaborationAccess(record, userCtx.userId).role;
+      json(res, 200, {
+        ok: true,
+        canCreate: !record || role === "owner",
+        share: record?.shareToken
+          ? prdWorkflowShareLinkSummary(
+              record,
+              record.shareToken,
+              serverPublicBaseUrl(req, host, uiPort),
+              userCtx.userId,
+            )
+          : null,
+      });
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/prd-workflow/share") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      const tapdId = String(payload?.tapdId || payload?.tapd_id || "").trim();
+      if (!tapdId) {
+        json(res, 400, { error: "Missing tapdId" });
+        return;
+      }
+      const existing = getPrdWorkflowCollaborationForUser(tapdId, userCtx.userId);
+      if (existing && prdWorkflowCollaborationAccess(existing, userCtx.userId).role !== "owner") {
+        json(res, 403, { error: "仅 Workflow 所有者可以创建分享链接" });
+        return;
+      }
+      const result = ensurePrdWorkflowShareLink({ tapdId, userId: userCtx.userId });
+      if (result.error) {
+        json(res, result.status || 400, { error: result.error });
+        return;
+      }
+      const scope = resolvePrdWorkflowScope(root, { ...payload, tapdId }, userCtx, "write");
+      if (!scope.error) prdWorkflowMigrateLegacyState(scope.executionRoot, scope.stateRoot, tapdId);
+      json(res, 200, {
+        ok: true,
+        created: result.created === true,
+        share: prdWorkflowShareLinkSummary(
+          result.record,
+          result.shareToken,
+          serverPublicBaseUrl(req, host, uiPort, payload),
+          userCtx.userId,
+        ),
+      });
+      return;
+    }
+    if (req.method === "DELETE" && url.pathname === "/api/prd-workflow/share") {
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      const tapdId = String(payload?.tapdId || payload?.tapd_id || "").trim();
+      if (!tapdId) {
+        json(res, 400, { error: "Missing tapdId" });
+        return;
+      }
+      const result = revokePrdWorkflowShareLink({ tapdId, userId: userCtx.userId });
+      if (result.error) {
+        json(res, result.status || 400, { error: result.error });
+        return;
+      }
+      json(res, 200, { ok: true, revoked: result.revoked === true, share: null });
+      return;
+    }
     if (req.method === "GET" && url.pathname === "/api/prd-workflow/collaboration") {
       const tapdId = String(url.searchParams.get("tapdId") || "").trim();
       if (!tapdId) {
@@ -10611,6 +10955,55 @@ export function startUiServer({
       }
       return;
     }
+    if (req.method === "GET" && url.pathname === "/api/workflows/state") {
+      try {
+        const workflow = normalizeWorkflowReference({
+          workflow: {
+            key: url.searchParams.get("workflow") || "",
+            namespace: url.searchParams.get("namespace") || "",
+            id: url.searchParams.get("id") || "",
+          },
+        });
+        if (workflow.error) {
+          json(res, 400, { error: workflow.error });
+          return;
+        }
+        if (workflow.namespace !== "tapd") {
+          json(res, 400, { error: `Unsupported workflow namespace: ${workflow.namespace}` });
+          return;
+        }
+        const flowId = String(url.searchParams.get("flowId") || "").trim();
+        const flowSource = String(url.searchParams.get("flowSource") || "user").trim() || "user";
+        const workflowScope = resolvePrdWorkflowScope(root, {
+          tapdId: workflow.id,
+          flowId,
+          flowSource,
+          archived: url.searchParams.get("archived") === "1",
+          workspaceId: url.searchParams.get("workspaceId") || "",
+          workflowShare: url.searchParams.get("workflowShare") || "",
+        }, userCtx);
+        if (workflowScope.error) {
+          json(res, workflowScope.status || 400, { error: workflowScope.error });
+          return;
+        }
+        const scopedRoot = workflowScope.stateRoot;
+        prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, workflow.id);
+        const runtimeOnly = url.searchParams.get("runtimeOnly") === "1" ||
+          url.searchParams.get("runtime_only") === "1" ||
+          url.searchParams.get("cached") === "1";
+        const baseSnapshot = runtimeOnly
+          ? prdWorkflowMaterializeSnapshot(workflowScope.executionRoot, scopedRoot, workflow.id, userCtx, { flowSource, flowId })
+          : await prdWorkflowSnapshot(workflowScope.executionRoot, scopedRoot, workflow.id, userCtx, { flowSource, flowId });
+        const snapshot = prdWorkflowWithAgentflowTokenDiagnostic(
+          baseSnapshot,
+          getSessionTokenFromRequest(req) || "",
+        );
+        json(res, 200, { ok: true, workflow, snapshot });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
     if (req.method === "GET" && url.pathname === "/api/prd-workflow/snapshot") {
       try {
         const tapdId = String(url.searchParams.get("tapdId") || "").trim();
@@ -10623,6 +11016,7 @@ export function startUiServer({
           flowSource,
           archived,
           workspaceId: url.searchParams.get("workspaceId") || "",
+          workflowShare: url.searchParams.get("workflowShare") || "",
         }, userCtx);
         if (workflowScope.error) {
           json(res, workflowScope.status || 400, { error: workflowScope.error });
@@ -10651,6 +11045,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/prd-workflow/snapshot") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -10815,6 +11213,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/prd-workflow/action") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -11237,6 +11639,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/prd-workflow/idempotency") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -11304,7 +11710,117 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "POST" && url.pathname === "/api/workflows/report") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      try {
+        const report = normalizeWorkflowReport(payload);
+        if (report.error) {
+          json(res, 400, { error: report.error });
+          return;
+        }
+        if (report.workflow.namespace !== "tapd") {
+          json(res, 400, { error: `Unsupported workflow namespace: ${report.workflow.namespace}` });
+          return;
+        }
+        const tapdId = report.workflow.id;
+        const flowId = report.flowId;
+        const flowSource = report.flowSource || "user";
+        const archived = payload.archived === true || payload.flowArchived === true;
+        const workflowScope = resolvePrdWorkflowScope(root, {
+          ...payload,
+          tapdId,
+          flowId,
+          flowSource,
+          archived,
+        }, userCtx, "write");
+        if (workflowScope.error) {
+          json(res, workflowScope.status || 400, { error: workflowScope.error });
+          return;
+        }
+        const scopedRoot = workflowScope.stateRoot;
+        prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
+        const currentSnapshot = prdWorkflowMaterializeSnapshot(
+          workflowScope.executionRoot,
+          scopedRoot,
+          tapdId,
+          userCtx,
+          { flowSource, flowId },
+        );
+        const acceptedRevisions = new Set([
+          String(currentSnapshot.runtimeRevision || "").trim(),
+          String(currentSnapshot.revision || "").trim(),
+        ].filter(Boolean));
+        if (report.expectedRevision && acceptedRevisions.size && !acceptedRevisions.has(report.expectedRevision)) {
+          json(res, 409, {
+            error: "Workflow state changed; refresh before reporting",
+            conflict: {
+              type: "workflow-revision-conflict",
+              expectedRevision: report.expectedRevision,
+              currentRevision: currentSnapshot.runtimeRevision || currentSnapshot.revision || "",
+              workflow: report.workflow,
+            },
+            snapshot: currentSnapshot,
+          });
+          return;
+        }
+        if (report.idempotencyKey) {
+          const existing = prdWorkflowFindCompletedIdempotencyEvent(scopedRoot, tapdId, report.idempotencyKey);
+          if (existing) {
+            json(res, 200, {
+              ok: true,
+              alreadyApplied: true,
+              report,
+              event: existing,
+              snapshot: currentSnapshot,
+            });
+            return;
+          }
+        }
+        const event = prdWorkflowAppendRuntimeEvent(scopedRoot, tapdId, {
+          ...report.event,
+          tapdId,
+          actor: {
+            userId: String(userCtx.userId || ""),
+            username: String(authUser.username || userCtx.userId || ""),
+          },
+        });
+        if (!event) throw new Error("Failed to store workflow report");
+        const snapshot = prdWorkflowWithAgentflowTokenDiagnostic(
+          prdWorkflowMaterializeSnapshot(
+            workflowScope.executionRoot,
+            scopedRoot,
+            tapdId,
+            userCtx,
+            { flowSource, flowId },
+          ),
+          getSessionTokenFromRequest(req) || "",
+        );
+        prdWorkflowBroadcast(
+          prdWorkflowKey(userCtx, flowSource, flowId, tapdId),
+          { type: "workflow-report", tapdId, workflow: report.workflow, event, snapshot },
+        );
+        json(res, 200, { ok: true, report, event, snapshot });
+      } catch (e) {
+        json(res, 500, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "POST" && url.pathname === "/api/prd-workflow/event") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -11359,6 +11875,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/prd-workflow/review-link") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Authentication required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -11439,7 +11959,18 @@ export function startUiServer({
       const tapdId = String(url.searchParams.get("tapdId") || "").trim();
       const flowId = String(url.searchParams.get("flowId") || "").trim();
       const flowSource = String(url.searchParams.get("flowSource") || "user").trim() || "user";
-      const key = prdWorkflowKey(userCtx, flowSource, flowId, tapdId);
+      const workflowShare = String(url.searchParams.get("workflowShare") || "").trim();
+      const workflowScope = resolvePrdWorkflowScope(root, {
+        tapdId,
+        flowId,
+        flowSource,
+        workflowShare,
+      }, userCtx);
+      if (workflowScope.error) {
+        json(res, workflowScope.status || 400, { error: workflowScope.error });
+        return;
+      }
+      const key = prdWorkflowKey(userCtx, flowSource, flowId, tapdId, workflowShare);
       let set = prdWorkflowSubscribers.get(key);
       if (!set) {
         set = new Set();
@@ -11483,6 +12014,7 @@ export function startUiServer({
           flowSource,
           archived,
           workspaceId: url.searchParams.get("workspaceId") || "",
+          workflowShare: url.searchParams.get("workflowShare") || "",
         }, userCtx);
         if (workflowScope.error) {
           res.writeHead(workflowScope.status || 400, { "Content-Type": "text/plain; charset=utf-8" });
@@ -13850,7 +14382,10 @@ export function startUiServer({
 
     if (req.method === "GET" && url.pathname === "/api/ui-context") {
       try {
-        json(res, 200, { workspaceRoot: root, ...uiConfig });
+        json(res, 200, {
+          ...uiConfig,
+          ...(authUser?.isAdmin ? { workspaceRoot: root } : {}),
+        });
       } catch (e) {
         json(res, 500, { error: (e && e.message) || String(e) });
       }
@@ -13920,6 +14455,10 @@ export function startUiServer({
     }
 
     if (req.method === "GET" && url.pathname === "/api/agentflow-config") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
       try {
         const cfg = readAgentflowUserConfigObject();
         const opencodeProvider = typeof cfg.opencodeProvider === "string" ? cfg.opencodeProvider : "";
@@ -13931,6 +14470,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/agentflow-config") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
       let payload;
       try {
         payload = JSON.parse(await readBody(req));
@@ -14020,8 +14563,11 @@ export function startUiServer({
 
     if (req.method === "GET" && url.pathname === "/api/user-env") {
       try {
+        const userEnvRows = readUserEnvRows(userCtx.userId);
         json(res, 200, {
-          env: readUserEnvRows(userCtx.userId),
+          env: authUser?.isAdmin
+            ? userEnvRows
+            : userEnvRows.filter((row) => !ADMIN_ONLY_USER_ENV_KEYS.has(String(row?.key || "").trim())),
           globalEnv: authUser?.isAdmin ? readGlobalEnvRows() : [],
           canEditGlobalEnv: Boolean(authUser?.isAdmin),
         });
@@ -14044,13 +14590,23 @@ export function startUiServer({
           json(res, 403, { error: "Admin permission required" });
           return;
         }
-        const envRows = writeUserEnvRows(userCtx.userId, payload?.env || []);
+        const requestedEnvRows = Array.isArray(payload?.env) ? payload.env : [];
+        if (!authUser?.isAdmin && requestedEnvRows.some((row) => ADMIN_ONLY_USER_ENV_KEYS.has(String(row?.key || "").trim()))) {
+          json(res, 403, { error: "Admin permission required for infrastructure environment keys" });
+          return;
+        }
+        const preservedAdminRows = authUser?.isAdmin
+          ? []
+          : readUserEnvRows(userCtx.userId).filter((row) => ADMIN_ONLY_USER_ENV_KEYS.has(String(row?.key || "").trim()));
+        const envRows = writeUserEnvRows(userCtx.userId, [...preservedAdminRows, ...requestedEnvRows]);
         const globalEnvRows = authUser?.isAdmin && Object.prototype.hasOwnProperty.call(payload || {}, "globalEnv")
           ? writeGlobalEnvRows(payload?.globalEnv || [])
           : readGlobalEnvRows();
         json(res, 200, {
           success: true,
-          env: envRows,
+          env: authUser?.isAdmin
+            ? envRows
+            : envRows.filter((row) => !ADMIN_ONLY_USER_ENV_KEYS.has(String(row?.key || "").trim())),
           globalEnv: authUser?.isAdmin ? globalEnvRows : [],
           canEditGlobalEnv: Boolean(authUser?.isAdmin),
         });
@@ -14061,6 +14617,10 @@ export function startUiServer({
     }
 
     if (req.method === "POST" && url.pathname === "/api/update-model-lists") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
       try {
         let opencodeProviderOverride = "";
         const raw = await readBody(req);