@fieldwangai/agentflow 0.1.133 → 0.1.135

package/bin/lib/workflow-report.mjs

@@ -21,6 +21,10 @@ function cleanString(value, max = 4000) {
   return String(value ?? "").trim().slice(0, max);
 }
 
+function hasOwn(value, key) {
+  return Boolean(value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key));
+}
+
 function stableValue(value) {
   if (Array.isArray(value)) return value.map((item) => stableValue(item));
   if (value && typeof value === "object") {
@@ -105,6 +109,67 @@ function normalizeWorkflowArtifact(value, index = 0, defaultScope = "action") {
   };
 }
 
+export function normalizeWorkflowTimelineProjection(value, index = 0) {
+  const raw = plainObject(value);
+  const kind = cleanString(raw.kind || raw.type, 80).toLowerCase();
+  const id = cleanString(raw.id || raw.key, 240);
+  if (!kind || !id) return null;
+  const source = cleanString(raw.source || raw.namespace, 120).toLowerCase();
+  const date = cleanString(raw.date || raw.targetDate || raw.target_date, 80);
+  const dimensions = mergeWorkflowGlobalState({}, plainObject(raw.dimensions || raw.facets));
+  const key = cleanString(raw.key || [source, kind, id].filter(Boolean).join(":"), 500);
+  return {
+    ...mergeWorkflowGlobalState({}, raw),
+    key: key || `${kind}:${id}`,
+    kind,
+    id,
+    title: cleanString(raw.title || raw.label || id, 500) || id,
+    ...(source ? { source } : {}),
+    ...(date ? { date } : {}),
+    dimensions,
+    order: Number.isFinite(Number(raw.order)) ? Number(raw.order) : index,
+  };
+}
+
+function normalizeWorkflowProjectionState(value = {}) {
+  const raw = mergeWorkflowGlobalState({}, plainObject(value));
+  if (Array.isArray(value?.timeline)) {
+    raw.timeline = value.timeline
+      .map((item, index) => normalizeWorkflowTimelineProjection(item, index))
+      .filter(Boolean)
+      .slice(0, 100);
+  } else {
+    delete raw.timeline;
+  }
+  return raw;
+}
+
+export function materializeWorkflowProjections(snapshot = {}, runtimeEvents = []) {
+  const base =
+    snapshot.projections ||
+    snapshot.workflowProjections ||
+    snapshot.workflow_projections ||
+    snapshot.raw?.projections ||
+    {};
+  let projections = normalizeWorkflowProjectionState(base);
+  const events = [...(Array.isArray(runtimeEvents) ? runtimeEvents : [])]
+    .sort((left, right) => eventTime(left) - eventTime(right));
+  for (const event of events) {
+    const next = event?.projections || event?.workflowProjections || event?.workflow_projections;
+    if (!next || typeof next !== "object" || Array.isArray(next) || !hasOwn(next, "timeline")) continue;
+    projections = {
+      ...projections,
+      timeline: Array.isArray(next.timeline)
+        ? next.timeline
+            .map((item, index) => normalizeWorkflowTimelineProjection(item, index))
+            .filter(Boolean)
+            .slice(0, 100)
+        : projections.timeline || [],
+    };
+  }
+  return projections;
+}
+
 export function mergeWorkflowGlobalState(base, patch) {
   if (!patch || typeof patch !== "object" || Array.isArray(patch)) return plainObject(base);
   const out = { ...plainObject(base) };
@@ -206,6 +271,22 @@ export function normalizeWorkflowReport(payload = {}) {
     .filter((item) => item && typeof item === "object" && !Array.isArray(item))
     .map((item, index) => normalizeWorkflowArtifact(item, index, action ? "action" : "global"));
 
+  const rawProjections = plainObject(payload.projections || payload.workflowProjections || payload.workflow_projections);
+  const hasProjections = Object.keys(rawProjections).length > 0 || hasOwn(payload, "projections");
+  if (hasProjections && !hasOwn(rawProjections, "timeline")) {
+    return { error: "projections requires timeline" };
+  }
+  if (hasProjections && !Array.isArray(rawProjections.timeline)) {
+    return { error: "projections.timeline must be an array" };
+  }
+  const invalidTimelineIndex = hasProjections
+    ? rawProjections.timeline.findIndex((item, index) => !normalizeWorkflowTimelineProjection(item, index))
+    : -1;
+  if (invalidTimelineIndex >= 0) {
+    return { error: `projections.timeline[${invalidTimelineIndex}] requires kind and id` };
+  }
+  const projections = hasProjections ? normalizeWorkflowProjectionState(rawProjections) : null;
+
   const rawGlobalState = plainObject(payload.globalState || payload.global_state);
   const hasGlobalState = Object.keys(rawGlobalState).length > 0;
   const globalStatePatch = plainObject(rawGlobalState.patch);
@@ -215,8 +296,8 @@ export function normalizeWorkflowReport(payload = {}) {
   if (hasGlobalState && !Object.keys(globalStatePatch).length && !globalStateRemove.length) {
     return { error: "globalState requires patch or remove" };
   }
-  if (!action && !artifacts.length && !hasGlobalState) {
-    return { error: "Workflow report requires action, artifacts, or globalState" };
+  if (!action && !artifacts.length && !hasGlobalState && !hasProjections) {
+    return { error: "Workflow report requires action, artifacts, globalState, or projections" };
   }
 
   const idempotencyKey = cleanString(
@@ -257,6 +338,7 @@ export function normalizeWorkflowReport(payload = {}) {
       scope: "global",
     }),
     artifacts,
+    ...(hasProjections ? { projections } : {}),
     ...(hasGlobalState ? {
       globalStatePatch,
       globalStateRemove,
@@ -268,6 +350,7 @@ export function normalizeWorkflowReport(payload = {}) {
     workflow,
     action,
     artifacts,
+    projections,
     globalState: hasGlobalState ? {
       mode: "merge",
       patch: globalStatePatch,
@@ -448,7 +531,7 @@ export function mergeWorkflowArtifactLists(left = [], right = [], defaultScope =
   return out;
 }
 
-export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = []) {
+export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtimeEvents = [], projections = {}) {
   const events = (Array.isArray(runtimeEvents) ? runtimeEvents : []).map((event) => ({
     id: event?.id || "",
     action: event?.action || event?.actionId || "",
@@ -457,10 +540,11 @@ export function workflowRuntimeRevision(globalState = {}, artifacts = [], runtim
     artifacts: event?.artifacts || [],
     globalStatePatch: event?.globalStatePatch || {},
     globalStateRemove: event?.globalStateRemove || [],
+    projections: event?.projections || {},
   }));
   const hash = crypto
     .createHash("sha256")
-    .update(JSON.stringify(stableValue({ globalState, artifacts, events })))
+    .update(JSON.stringify(stableValue({ globalState, artifacts, projections, events })))
     .digest("hex")
     .slice(0, 24);
   return `runtime:${hash}`;

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,