@fieldwangai/agentflow 0.1.133 → 0.1.135

package/bin/lib/prd-workflow-collaboration.mjs

@@ -2,6 +2,7 @@ import crypto from "crypto";
 import fs from "fs";
 import path from "path";
 import { getAgentflowDataRoot } from "./paths.mjs";
+import { getTeamForUser } from "./teams.mjs";
 
 const REGISTRY_VERSION = 1;
 
@@ -52,11 +53,14 @@ function publicWorkflow(record, userId = "") {
   if (!record) return null;
   const actorId = normalizeUserId(userId);
   const members = record.members && typeof record.members === "object" ? record.members : {};
+  const access = prdWorkflowCollaborationAccess(record, actorId);
   return {
     id: record.id,
     tapdId: record.tapdId,
     ownerId: record.ownerId,
-    role: actorId === record.ownerId ? "owner" : String(members[actorId] || ""),
+    role: access.role,
+    accessSource: access.source,
+    teamId: String(record.teamId || getTeamForUser(record.ownerId)?.id || ""),
     memberCount: Object.keys(members).length,
     members: Object.entries(members).map(([id, role]) => ({ userId: id, role })),
     shareActive: Boolean(record.shareToken),
@@ -69,11 +73,17 @@ function publicWorkflow(record, userId = "") {
 export function prdWorkflowCollaborationAccess(record, userId) {
   if (!record) return { allowed: true, role: "" };
   const actorId = normalizeUserId(userId);
-  const role = actorId === record.ownerId ? "owner" : String(record.members?.[actorId] || "");
+  const directRole = actorId === record.ownerId ? "owner" : String(record.members?.[actorId] || "");
+  const actorTeam = getTeamForUser(actorId);
+  const recordTeamId = String(record.teamId || getTeamForUser(record.ownerId)?.id || "");
+  const teamRole = actorTeam?.status === "active" && actorTeam.id === recordTeamId ? "viewer" : "";
+  const role = directRole || teamRole;
   return {
     allowed: role === "owner" || role === "editor" || role === "viewer",
     writable: role === "owner" || role === "editor",
     role,
+    source: directRole ? "member" : teamRole ? "team" : "",
+    teamId: teamRole ? recordTeamId : "",
   };
 }
 
@@ -109,7 +119,17 @@ export function listPrdWorkflowCollaborationsForUser(userId) {
   const actorId = normalizeUserId(userId);
   if (!actorId) return [];
   return Object.values(readRegistry().workflows)
-    .filter((record) => prdWorkflowCollaborationAccess(record, actorId).allowed)
+    .filter((record) => (
+      record?.ownerId === actorId || Boolean(record?.members?.[actorId])
+    ))
+    .sort((left, right) => String(right?.updatedAt || "").localeCompare(String(left?.updatedAt || "")));
+}
+
+export function listPrdWorkflowCollaborationsForTeam(teamId) {
+  const id = String(teamId || "").trim();
+  if (!id) return [];
+  return Object.values(readRegistry().workflows)
+    .filter((record) => String(record?.teamId || getTeamForUser(record?.ownerId)?.id || "") === id)
     .sort((left, right) => String(right?.updatedAt || "").localeCompare(String(left?.updatedAt || "")));
 }
 
@@ -129,6 +149,7 @@ export function ensurePrdWorkflowCollaboration({ tapdId, userId }) {
     id: workflowId,
     tapdId: normalizedTapdId,
     ownerId,
+    teamId: String(getTeamForUser(ownerId)?.id || ""),
     members: { [ownerId]: "owner" },
     createdAt: now,
     updatedAt: now,

package/bin/lib/teams.mjs

@@ -0,0 +1,160 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { getAgentflowDataRoot } from "./paths.mjs";
+
+const REGISTRY_VERSION = 1;
+
+function registryPath() {
+  return path.join(getAgentflowDataRoot(), "organization", "teams.json");
+}
+
+function normalizeUserId(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function normalizeTeamId(value) {
+  return String(value || "").trim();
+}
+
+function normalizeMembers(value) {
+  const members = Array.isArray(value) ? value : [];
+  return Array.from(new Set(members.map(normalizeUserId).filter(Boolean)));
+}
+
+function readRegistry() {
+  try {
+    const filePath = registryPath();
+    if (!fs.existsSync(filePath)) return { version: REGISTRY_VERSION, teams: {} };
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return {
+      version: REGISTRY_VERSION,
+      teams: parsed?.teams && typeof parsed.teams === "object" && !Array.isArray(parsed.teams)
+        ? parsed.teams
+        : {},
+    };
+  } catch {
+    return { version: REGISTRY_VERSION, teams: {} };
+  }
+}
+
+function writeRegistry(registry) {
+  const filePath = registryPath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify({
+    version: REGISTRY_VERSION,
+    teams: registry?.teams || {},
+  }, null, 2) + "\n", "utf-8");
+  fs.renameSync(tempPath, filePath);
+}
+
+function publicTeam(record) {
+  if (!record) return null;
+  const members = normalizeMembers(record.members);
+  return {
+    id: String(record.id || ""),
+    name: String(record.name || ""),
+    description: String(record.description || ""),
+    status: record.status === "inactive" ? "inactive" : "active",
+    members,
+    memberCount: members.length,
+    createdAt: String(record.createdAt || ""),
+    updatedAt: String(record.updatedAt || ""),
+  };
+}
+
+export function listTeams({ includeInactive = true } = {}) {
+  return Object.values(readRegistry().teams)
+    .map(publicTeam)
+    .filter((team) => includeInactive || team.status === "active")
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+export function getTeamById(teamId) {
+  return publicTeam(readRegistry().teams[normalizeTeamId(teamId)] || null);
+}
+
+export function getTeamForUser(userId, { includeInactive = false } = {}) {
+  const id = normalizeUserId(userId);
+  if (!id) return null;
+  return listTeams({ includeInactive }).find((team) => team.members.includes(id)) || null;
+}
+
+export function createTeam({ name, description = "" } = {}) {
+  const normalizedName = String(name || "").trim();
+  if (!normalizedName) return { error: "团队名称不能为空", status: 400 };
+  const registry = readRegistry();
+  const duplicate = Object.values(registry.teams).some((team) => (
+    String(team?.name || "").trim().toLowerCase() === normalizedName.toLowerCase()
+  ));
+  if (duplicate) return { error: "已存在同名团队", status: 409 };
+  const now = new Date().toISOString();
+  const id = `team_${crypto.randomBytes(10).toString("hex")}`;
+  const record = {
+    id,
+    name: normalizedName,
+    description: String(description || "").trim(),
+    status: "active",
+    members: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+  registry.teams[id] = record;
+  writeRegistry(registry);
+  return { team: publicTeam(record), created: true };
+}
+
+export function updateTeam(teamId, patch = {}) {
+  const id = normalizeTeamId(teamId);
+  const registry = readRegistry();
+  const record = registry.teams[id];
+  if (!record) return { error: "团队不存在", status: 404 };
+  if (Object.prototype.hasOwnProperty.call(patch, "name")) {
+    const name = String(patch.name || "").trim();
+    if (!name) return { error: "团队名称不能为空", status: 400 };
+    const duplicate = Object.values(registry.teams).some((team) => (
+      team?.id !== id && String(team?.name || "").trim().toLowerCase() === name.toLowerCase()
+    ));
+    if (duplicate) return { error: "已存在同名团队", status: 409 };
+    record.name = name;
+  }
+  if (Object.prototype.hasOwnProperty.call(patch, "description")) {
+    record.description = String(patch.description || "").trim();
+  }
+  if (Object.prototype.hasOwnProperty.call(patch, "status")) {
+    record.status = patch.status === "inactive" ? "inactive" : "active";
+  }
+  record.updatedAt = new Date().toISOString();
+  writeRegistry(registry);
+  return { team: publicTeam(record) };
+}
+
+export function setTeamMembers(teamId, members = []) {
+  const id = normalizeTeamId(teamId);
+  const registry = readRegistry();
+  const record = registry.teams[id];
+  if (!record) return { error: "团队不存在", status: 404 };
+  const normalized = normalizeMembers(members);
+  for (const team of Object.values(registry.teams)) {
+    if (!team || team.id === id) continue;
+    team.members = normalizeMembers(team.members).filter((memberId) => !normalized.includes(memberId));
+  }
+  record.members = normalized;
+  record.updatedAt = new Date().toISOString();
+  writeRegistry(registry);
+  return { team: publicTeam(record) };
+}
+
+export function deleteTeam(teamId) {
+  const id = normalizeTeamId(teamId);
+  const registry = readRegistry();
+  const record = registry.teams[id];
+  if (!record) return { error: "团队不存在", status: 404 };
+  if (normalizeMembers(record.members).length > 0) {
+    return { error: "请先移出团队中的全部成员", status: 409 };
+  }
+  delete registry.teams[id];
+  writeRegistry(registry);
+  return { deleted: true, teamId: id };
+}

package/bin/lib/ui-server.mjs

@@ -145,6 +145,8 @@ import {
   getWorkspaceCollaborationForProject,
   listWorkspaceCollaborationsForUser,
   removeWorkspaceCollaborationMember,
+  removeWorkspaceCollaborationTeamShare,
+  setWorkspaceCollaborationTeamShare,
   updateWorkspaceCollaborationFlow,
   workspaceCollaborationAccess,
   workspaceCollaborationSummary,
@@ -157,14 +159,25 @@ import {
   getPrdWorkflowCollaborationForUser,
   ensurePrdWorkflowShareLink,
   listPrdWorkflowCollaborationsForUser,
+  listPrdWorkflowCollaborationsForTeam,
   prdWorkflowCollaborationAccess,
   prdWorkflowCollaborationSummary,
   removePrdWorkflowCollaborationMember,
   revokePrdWorkflowShareLink,
 } from "./prd-workflow-collaboration.mjs";
+import {
+  createTeam,
+  deleteTeam,
+  getTeamById,
+  getTeamForUser,
+  listTeams,
+  setTeamMembers,
+  updateTeam,
+} from "./teams.mjs";
 import {
   legacyOverallToGlobalState,
   materializeWorkflowGlobalState,
+  materializeWorkflowProjections,
   mergeWorkflowArtifactLists,
   mergeWorkflowArtifacts,
   mergeWorkflowGlobalState,
@@ -3305,6 +3318,7 @@ function workspaceCollaborationSummaryWithUsers(record, userId) {
   const summary = workspaceCollaborationSummary(record, userId);
   if (!summary) return null;
   const users = readAuthUsers();
+  const teams = new Map(listTeams().map((team) => [team.id, team]));
   return {
     ...summary,
     ownerUsername: String(users[summary.ownerId]?.username || summary.ownerId),
@@ -3312,6 +3326,23 @@ function workspaceCollaborationSummaryWithUsers(record, userId) {
       ...member,
       username: String(users[member.userId]?.username || member.userId),
     })),
+    teamShares: (summary.teamShares || []).map((share) => ({
+      ...share,
+      teamName: String(teams.get(share.teamId)?.name || share.teamId),
+    })),
+  };
+}
+
+function teamSummaryWithUsers(team) {
+  if (!team) return null;
+  const users = readAuthUsers();
+  return {
+    ...team,
+    members: (team.members || []).map((userId) => ({
+      userId,
+      username: String(users[userId]?.username || userId),
+      isAdmin: Boolean(users[userId]?.isAdmin),
+    })),
   };
 }
 
@@ -3434,6 +3465,23 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
     || snapshot?.title
     || "",
   ).trim();
+  const timeline = Array.isArray(snapshot?.projections?.timeline)
+    ? snapshot.projections.timeline
+        .filter((entry) => entry && typeof entry === "object" && !Array.isArray(entry))
+        .map((entry) => ({
+          key: String(entry.key || [entry.source, entry.kind, entry.id].filter(Boolean).join(":")),
+          kind: String(entry.kind || ""),
+          id: String(entry.id || ""),
+          title: String(entry.title || entry.label || entry.id || ""),
+          date: String(entry.date || ""),
+          source: String(entry.source || ""),
+          dimensions: entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+            ? entry.dimensions
+            : {},
+          order: Number.isFinite(Number(entry.order)) ? Number(entry.order) : 0,
+        }))
+        .filter((entry) => entry.kind && entry.id)
+    : [];
   const updatedAtTimestamp = Math.max(
     prdWorkflowDashboardTimestamp(record),
     prdWorkflowDashboardTimestamp(snapshot),
@@ -3451,6 +3499,7 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
     platforms,
     actionCount: actions.length,
     completedActionCount: completedActions,
+    timeline,
     latestAction: latestAction
       ? {
           title: String(latestAction.title || latestAction.label || latestAction.action || latestAction.id || "").trim(),
@@ -3462,11 +3511,80 @@ function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
     ownerId: String(collaboration.ownerId || ""),
     ownerUsername: String(collaboration.ownerUsername || collaboration.ownerId || ""),
     memberCount: Number(collaboration.memberCount || 0),
+    accessSource: String(collaboration.accessSource || ""),
+    teamId: String(collaboration.teamId || ""),
+    teamName: String(getTeamById(collaboration.teamId)?.name || ""),
     shareActive: collaboration.shareActive === true,
     updatedAt: updatedAtTimestamp ? new Date(updatedAtTimestamp).toISOString() : String(record?.updatedAt || ""),
   };
 }
 
+function prdWorkflowDashboardTimeline(workflows = []) {
+  const buckets = new Map();
+  const assignedWorkflowIds = new Set();
+  const rows = [...(Array.isArray(workflows) ? workflows : [])].sort((left, right) => {
+    const leftAt = Date.parse(String(left?.updatedAt || ""));
+    const rightAt = Date.parse(String(right?.updatedAt || ""));
+    if (Number.isFinite(leftAt) && Number.isFinite(rightAt)) return leftAt - rightAt;
+    if (Number.isFinite(leftAt) !== Number.isFinite(rightAt)) return Number.isFinite(leftAt) ? 1 : -1;
+    return String(left?.id || left?.tapdId || "").localeCompare(String(right?.id || right?.tapdId || ""));
+  });
+  for (const workflow of rows) {
+    const workflowId = String(workflow?.id || workflow?.tapdId || "");
+    const seen = new Set();
+    for (const entry of Array.isArray(workflow?.timeline) ? workflow.timeline : []) {
+      const key = String(entry?.key || [entry?.source, entry?.kind, entry?.id].filter(Boolean).join(":"));
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      assignedWorkflowIds.add(workflowId);
+      const current = buckets.get(key) || {
+        key,
+        kind: String(entry.kind || ""),
+        id: String(entry.id || ""),
+        title: String(entry.title || entry.id || ""),
+        date: String(entry.date || ""),
+        source: String(entry.source || ""),
+        dimensions: entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+          ? entry.dimensions
+          : {},
+        order: Number.isFinite(Number(entry.order)) ? Number(entry.order) : 0,
+        workflowCount: 0,
+        completedCount: 0,
+        blockedCount: 0,
+        workflowIds: [],
+      };
+      current.kind = String(entry.kind || current.kind);
+      current.id = String(entry.id || current.id);
+      current.title = String(entry.title || current.title);
+      current.date = String(entry.date || current.date);
+      current.source = String(entry.source || current.source);
+      current.dimensions = entry.dimensions && typeof entry.dimensions === "object" && !Array.isArray(entry.dimensions)
+        ? entry.dimensions
+        : current.dimensions;
+      current.order = Number.isFinite(Number(entry.order)) ? Number(entry.order) : current.order;
+      current.workflowCount += 1;
+      if (workflow?.state === "completed") current.completedCount += 1;
+      if (workflow?.state === "blocked") current.blockedCount += 1;
+      current.workflowIds.push(workflowId);
+      buckets.set(key, current);
+    }
+  }
+  const timeline = Array.from(buckets.values()).sort((left, right) => {
+    const leftAt = Date.parse(String(left.date || ""));
+    const rightAt = Date.parse(String(right.date || ""));
+    const leftValid = Number.isFinite(leftAt);
+    const rightValid = Number.isFinite(rightAt);
+    if (leftValid && rightValid && leftAt !== rightAt) return leftAt - rightAt;
+    if (leftValid !== rightValid) return leftValid ? -1 : 1;
+    if (left.order !== right.order) return left.order - right.order;
+    return left.title.localeCompare(right.title, undefined, { numeric: true, sensitivity: "base" });
+  });
+  return {
+    timeline,
+    unassignedCount: rows.filter((workflow) => !assignedWorkflowIds.has(String(workflow?.id || workflow?.tapdId || ""))).length,
+  };
+}
+
 function workspaceConversationsPath(scopedRoot) {
   return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "conversations.json");
 }
@@ -11050,13 +11168,15 @@ function prdWorkflowMergeRuntimeEvents(scopedRoot, tapdId, snapshot) {
   const overall = prdWorkflowOverallFromEvents(tapdId, snapshot, runtimeEvents);
   const globalState = prdWorkflowGlobalStateFromEvents(tapdId, snapshot, runtimeEvents);
   const artifacts = mergeWorkflowArtifacts(snapshot?.artifacts, runtimeEvents);
+  const projections = materializeWorkflowProjections(snapshot, runtimeEvents);
   return {
     ...snapshot,
     workflow: globalState.workflow,
     overall,
     globalState,
     artifacts,
-    runtimeRevision: workflowRuntimeRevision(globalState, artifacts, runtimeEvents),
+    projections,
+    runtimeRevision: workflowRuntimeRevision(globalState, artifacts, runtimeEvents, projections),
     runtimeEvents,
     events,
     sources: {
@@ -12473,16 +12593,40 @@ export function startUiServer({
         return;
       }
       try {
-        const workflows = listPrdWorkflowCollaborationsForUser(userCtx.userId).map((record) => {
+        const view = String(url.searchParams.get("view") || "personal").trim().toLowerCase();
+        let team = null;
+        let records;
+        if (view === "team") {
+          const requestedTeamId = String(url.searchParams.get("teamId") || "").trim();
+          team = requestedTeamId && authUser?.isAdmin
+            ? getTeamById(requestedTeamId)
+            : getTeamForUser(userCtx.userId);
+          if (!team || team.status !== "active") {
+            json(res, 200, { ok: true, view: "team", team: null, workflows: [], timeline: [], unassignedCount: 0 });
+            return;
+          }
+          records = listPrdWorkflowCollaborationsForTeam(team.id);
+        } else {
+          records = listPrdWorkflowCollaborationsForUser(userCtx.userId);
+        }
+        const workflows = records.map((record) => {
           const stateRoot = path.resolve(getAgentflowUserDataRoot(record.ownerId));
           const tapdId = String(record.tapdId || "").trim();
           const project = prdWorkflowReadProjectState(stateRoot, tapdId);
           const latestClient = prdWorkflowLatestClientSnapshot(stateRoot, stateRoot, tapdId);
           const legacy = prdWorkflowReadCachedSnapshot(stateRoot, tapdId);
           const snapshot = project?.snapshot || latestClient || legacy?.snapshot || {};
-          return prdWorkflowDashboardSummary(record, snapshot, userCtx);
+          const materialized = prdWorkflowMergeRuntimeEvents(stateRoot, tapdId, snapshot);
+          return prdWorkflowDashboardSummary(record, materialized, userCtx);
+        });
+        const dashboardTimeline = prdWorkflowDashboardTimeline(workflows);
+        json(res, 200, {
+          ok: true,
+          view: view === "team" ? "team" : "personal",
+          team: teamSummaryWithUsers(team),
+          workflows,
+          ...dashboardTimeline,
         });
-        json(res, 200, { ok: true, workflows });
       } catch (error) {
         json(res, 500, { error: (error && error.message) || String(error) });
       }
@@ -13587,6 +13731,13 @@ export function startUiServer({
           json(res, workflowScope.status || 400, { error: workflowScope.error });
           return;
         }
+        if (!workflowScope.collaboration) {
+          const ensured = ensurePrdWorkflowCollaboration({ tapdId, userId: userCtx.userId });
+          if (ensured.error) {
+            json(res, ensured.status || 400, { error: ensured.error });
+            return;
+          }
+        }
         const scopedRoot = workflowScope.stateRoot;
         prdWorkflowMigrateLegacyState(workflowScope.executionRoot, scopedRoot, tapdId);
         const currentSnapshot = prdWorkflowMaterializeSnapshot(
@@ -14158,6 +14309,62 @@ export function startUiServer({
       return;
     }
 
+    if (req.method === "GET" && url.pathname === "/api/teams/me") {
+      const team = getTeamForUser(userCtx.userId);
+      json(res, 200, { team: teamSummaryWithUsers(team) });
+      return;
+    }
+
+    if (url.pathname === "/api/admin/teams") {
+      if (!authUser?.isAdmin) {
+        json(res, 403, { error: "Admin permission required" });
+        return;
+      }
+      if (req.method === "GET") {
+        const assigned = new Set(listTeams().flatMap((team) => team.members || []));
+        const users = Object.entries(readAuthUsers()).map(([userId, user]) => ({
+          userId,
+          username: String(user?.username || userId),
+          isAdmin: Boolean(user?.isAdmin),
+          assigned: assigned.has(userId),
+          teamId: getTeamForUser(userId, { includeInactive: true })?.id || "",
+        }));
+        json(res, 200, { teams: listTeams().map(teamSummaryWithUsers), users });
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(await readBody(req));
+      } catch {
+        json(res, 400, { error: "Invalid JSON body" });
+        return;
+      }
+      let result;
+      if (req.method === "POST") {
+        result = createTeam(payload || {});
+      } else if (req.method === "PATCH") {
+        result = updateTeam(payload?.teamId, payload || {});
+      } else if (req.method === "PUT") {
+        const users = readAuthUsers();
+        const memberIds = Array.isArray(payload?.members) ? payload.members.map((value) => String(value || "").trim().toLowerCase()) : [];
+        const unknown = memberIds.find((userId) => !users[userId]);
+        result = unknown
+          ? { error: `用户不存在：${unknown}`, status: 404 }
+          : setTeamMembers(payload?.teamId, memberIds);
+      } else if (req.method === "DELETE") {
+        result = deleteTeam(payload?.teamId);
+      } else {
+        json(res, 405, { error: "Method not allowed" });
+        return;
+      }
+      if (result?.error) {
+        json(res, result.status || 400, { error: result.error });
+        return;
+      }
+      json(res, 200, { ok: true, ...result, teams: listTeams().map(teamSummaryWithUsers) });
+      return;
+    }
+
     if (url.pathname === "/api/feedback") {
       if (req.method === "POST") {
         let payload;
@@ -14345,6 +14552,8 @@ export function startUiServer({
     if (url.pathname === "/api/flows") {
       if (req.method === "GET") {
         try {
+          const projectView = String(url.searchParams.get("view") || "all").trim().toLowerCase();
+          const currentTeam = getTeamForUser(userCtx.userId);
           const flows = listFlowsJson(root, { ...userCtx, includeWorkspaceFlows: true })
             .filter((flow) => (
               !workspaceFlowCollaborationGuard(
@@ -14387,7 +14596,22 @@ export function startUiServer({
             });
             existingCollaborationIds.add(record.id);
           }
-          json(res, 200, flows);
+          const visibleFlows = projectView === "team"
+            ? flows.filter((flow) => (
+                currentTeam
+                && Array.isArray(flow.collaboration?.teamShares)
+                && flow.collaboration.teamShares.some((share) => share.teamId === currentTeam.id)
+              ))
+            : projectView === "personal"
+              ? flows.filter((flow) => (
+                  !flow.collaboration
+                  || flow.collaboration.ownerId === userCtx.userId
+                  || flow.collaboration.members?.some((member) => member.userId === userCtx.userId)
+                  || flow.source === "builtin"
+                  || flow.source === "admin"
+                ))
+              : flows;
+          json(res, 200, visibleFlows);
         } catch (e) {
           json(res, 500, { error: (e && e.message) || String(e) });
         }
@@ -14714,6 +14938,74 @@ export function startUiServer({
       return;
     }
 
+    if (url.pathname === "/api/workspace/collaboration/team-share" && (req.method === "POST" || req.method === "DELETE")) {
+      try {
+        const payload = JSON.parse(await readBody(req));
+        const flowId = String(payload?.flowId || "").trim();
+        const flowSource = String(payload?.flowSource || "user").trim();
+        const archived = payload?.archived === true || payload?.flowArchived === true;
+        if (!flowId || (flowSource !== "workspace" && flowSource !== "user")) {
+          json(res, 400, { error: "当前 Project 不支持团队分享" });
+          return;
+        }
+        const targetTeam = getTeamById(payload?.teamId);
+        const actorTeam = getTeamForUser(userCtx.userId);
+        if (!targetTeam || targetTeam.status !== "active") {
+          json(res, 404, { error: "团队不存在或已停用" });
+          return;
+        }
+        if (!authUser?.isAdmin && actorTeam?.id !== targetTeam.id) {
+          json(res, 403, { error: "只能分享给自己所在的团队" });
+          return;
+        }
+        const scoped = resolveWorkspaceScopeRoot(root, {
+          flowId,
+          flowSource,
+          workspaceId: payload.workspaceId || "",
+          archived,
+        }, userCtx);
+        if (scoped.error) {
+          json(res, scoped.status || 400, { error: scoped.error });
+          return;
+        }
+        const ensured = ensureWorkspaceCollaboration({
+          flowId,
+          flowSource,
+          archived,
+          userId: userCtx.userId,
+        });
+        if (ensured.error) {
+          json(res, ensured.status || 400, { error: ensured.error });
+          return;
+        }
+        const result = req.method === "POST"
+          ? setWorkspaceCollaborationTeamShare({
+              workspaceId: ensured.workspace.id,
+              userId: userCtx.userId,
+              teamId: targetTeam.id,
+              role: payload?.role,
+            })
+          : removeWorkspaceCollaborationTeamShare({
+              workspaceId: ensured.workspace.id,
+              userId: userCtx.userId,
+              teamId: targetTeam.id,
+            });
+        if (result.error) {
+          json(res, result.status || 400, { error: result.error });
+          return;
+        }
+        const record = getWorkspaceCollaborationForProject({ workspaceId: ensured.workspace.id });
+        json(res, 200, {
+          ok: true,
+          workspace: workspaceCollaborationSummaryWithUsers(record, userCtx.userId),
+          team: teamSummaryWithUsers(targetTeam),
+        });
+      } catch (e) {
+        json(res, 400, { error: (e && e.message) || String(e) });
+      }
+      return;
+    }
+
     if (req.method === "DELETE" && url.pathname === "/api/workspace/collaboration/share") {
       try {
         const payload = JSON.parse(await readBody(req));