@fieldwangai/agentflow 0.1.131 → 0.1.134

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,11 +159,21 @@ 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,
@@ -3305,6 +3317,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 +3325,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),
+    })),
   };
 }
 
@@ -3462,6 +3492,9 @@ 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 || ""),
   };
@@ -12473,7 +12506,23 @@ 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: [] });
+            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);
@@ -12482,7 +12531,7 @@ export function startUiServer({
           const snapshot = project?.snapshot || latestClient || legacy?.snapshot || {};
           return prdWorkflowDashboardSummary(record, snapshot, userCtx);
         });
-        json(res, 200, { ok: true, workflows });
+        json(res, 200, { ok: true, view: view === "team" ? "team" : "personal", team: teamSummaryWithUsers(team), workflows });
       } catch (error) {
         json(res, 500, { error: (error && error.message) || String(error) });
       }
@@ -14158,6 +14207,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 +14450,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 +14494,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 +14836,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));

package/bin/lib/workspace-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;
 const DEFAULT_INVITE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -67,15 +68,19 @@ function publicWorkspace(record, userId = "") {
   if (!record) return null;
   const actorId = normalizeUserId(userId);
   const members = record.members && typeof record.members === "object" ? record.members : {};
+  const access = workspaceCollaborationAccess(record, actorId);
   return {
     id: record.id,
     flowId: record.flowId,
     flowSource: record.projectSource || record.flowSource || "workspace",
     archived: record.archived === true,
     ownerId: record.ownerId,
-    role: actorId === record.ownerId ? "owner" : members[actorId] || "",
+    role: access.role,
+    accessSource: access.source,
+    teamId: access.teamId,
     memberCount: Object.keys(members).length,
     members: Object.entries(members).map(([id, role]) => ({ userId: id, role })),
+    teamShares: Object.entries(record.teamShares || {}).map(([teamId, role]) => ({ teamId, role })),
     createdAt: record.createdAt || "",
     updatedAt: record.updatedAt || "",
   };
@@ -98,12 +103,19 @@ export function getWorkspaceCollaborationById(workspaceId) {
 export function workspaceCollaborationAccess(record, userId) {
   if (!record) return { allowed: true, role: "" };
   const id = normalizeUserId(userId);
-  const role = id === record.ownerId ? "owner" : String(record.members?.[id] || "");
+  const directRole = id === record.ownerId ? "owner" : String(record.members?.[id] || "");
+  const team = getTeamForUser(id);
+  const teamRole = team ? String(record.teamShares?.[team.id] || "") : "";
+  const role = directRole === "owner" || directRole === "editor" || teamRole === "editor"
+    ? directRole === "owner" ? "owner" : "editor"
+    : directRole === "viewer" || teamRole === "viewer" ? "viewer" : "";
   return {
     allowed: role === "owner" || role === "editor" || role === "viewer",
     writable: role === "owner" || role === "editor",
     runnable: role === "owner" || role === "editor",
     role,
+    source: directRole ? "member" : teamRole ? "team" : "",
+    teamId: teamRole ? team?.id || "" : "",
   };
 }
 
@@ -256,6 +268,44 @@ export function addWorkspaceCollaborationMember({
   return { workspace: publicWorkspace(record, actorId), memberUserId: targetId };
 }
 
+export function setWorkspaceCollaborationTeamShare({
+  workspaceId,
+  userId,
+  teamId,
+  role = "viewer",
+}) {
+  const registry = readRegistry();
+  const record = registry.workspaces[String(workspaceId || "").trim()];
+  if (!record) return { error: "Workspace collaboration not found", status: 404 };
+  const actorId = normalizeUserId(userId);
+  const targetTeamId = String(teamId || "").trim();
+  if (workspaceCollaborationAccess(record, actorId).role !== "owner") {
+    return { error: "Only the workspace owner can share with a team", status: 403 };
+  }
+  if (!targetTeamId) return { error: "Missing teamId", status: 400 };
+  record.teamShares = record.teamShares && typeof record.teamShares === "object" ? record.teamShares : {};
+  record.teamShares[targetTeamId] = role === "editor" ? "editor" : "viewer";
+  record.updatedAt = new Date().toISOString();
+  writeRegistry(registry);
+  return { workspace: publicWorkspace(record, actorId), teamId: targetTeamId };
+}
+
+export function removeWorkspaceCollaborationTeamShare({ workspaceId, userId, teamId }) {
+  const registry = readRegistry();
+  const record = registry.workspaces[String(workspaceId || "").trim()];
+  if (!record) return { error: "Workspace collaboration not found", status: 404 };
+  const actorId = normalizeUserId(userId);
+  const targetTeamId = String(teamId || "").trim();
+  if (workspaceCollaborationAccess(record, actorId).role !== "owner") {
+    return { error: "Only the workspace owner can revoke a team share", status: 403 };
+  }
+  const removed = Boolean(record.teamShares?.[targetTeamId]);
+  if (removed) delete record.teamShares[targetTeamId];
+  record.updatedAt = new Date().toISOString();
+  writeRegistry(registry);
+  return { workspace: publicWorkspace(record, actorId), teamId: targetTeamId, removed };
+}
+
 export function removeWorkspaceCollaborationMember({
   workspaceId,
   userId,