@growthub/cli 0.14.2 → 0.14.3

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/workflows/WorkflowSurface.jsx

@@ -44,6 +44,11 @@ import {
   validateOrchestrationGraph
 } from "@/lib/orchestration-graph";
 import { resolveConnectorAction } from "@/lib/orchestration-sidecar-routing";
+import {
+  nodeSandboxRecordRef,
+  patchSandboxRowInConfig,
+  withGraphSandboxRecordRefs
+} from "@/lib/orchestration-publish";
 import { OrchestrationGraphCanvas } from "../data-model/components/OrchestrationGraphCanvas.jsx";
 import { OrchestrationGraphEmptyCanvas } from "../data-model/components/OrchestrationGraphEmptyCanvas.jsx";
 import { OrchestrationNodeConfigPanel } from "../data-model/components/OrchestrationNodeConfigPanel.jsx";
@@ -117,47 +122,6 @@ function resolveRegistryRefForSandbox(workspaceConfig, sandboxRow) {
   return firstRegistryRow ? { object: firstRegistryObject, row: firstRegistryRow } : null;
 }
 
-function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
-  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
-  return {
-    ...workspaceConfig,
-    dataModel: {
-      ...workspaceConfig.dataModel,
-      objects: objects.map((object) => {
-        if (object?.id !== objectId) return object;
-        const rows = Array.isArray(object.rows) ? object.rows : [];
-        return {
-          ...object,
-          rows: rows.map((row, index) => (index === rowIndex ? { ...row, ...fields } : row)),
-        };
-      }),
-    },
-  };
-}
-
-function nodeSandboxRecordRef(objectId, rowName, nodeId) {
-  return {
-    objectId: String(objectId || "").trim(),
-    rowName: String(rowName || "").trim(),
-    nodeId: String(nodeId || "").trim()
-  };
-}
-
-function withGraphSandboxRecordRefs(graph, objectId, rowName) {
-  const parsed = parseOrchestrationGraph(graph) || graph;
-  if (!parsed || typeof parsed !== "object") return parsed;
-  return {
-    ...parsed,
-    nodes: (Array.isArray(parsed.nodes) ? parsed.nodes : []).map((node) => ({
-      ...node,
-      config: {
-        ...(node?.config || {}),
-        sandboxRecordRef: nodeSandboxRecordRef(objectId, rowName, node?.id)
-      }
-    }))
-  };
-}
-
 const WORKFLOW_ACTION_GROUPS = [
   {
     label: "Data",
@@ -201,90 +165,6 @@ function getWorkspaceObjectOptions(workspaceConfig) {
     }));
 }
 
-function normalizeDeltaTags(tags) {
-  return Array.from(new Set((Array.isArray(tags) ? tags : [])
-    .map((tag) => String(tag || "").trim().toLowerCase())
-    .filter(Boolean)));
-}
-
-function inferDeltaTagsForWorkflowNode(node, config) {
-  const tags = [];
-  const type = String(node?.type || "").trim();
-  const action = String(config?.action || node?.id || "").trim();
-  if (type === "thinAdapter") tags.push("model", "prompt", "routing");
-  if (type === "ai-agent") tags.push("model", "prompt", "output");
-  if (type === "data-action" || type === "data-trigger") tags.push("input", "output");
-  if (type === "flow-control") tags.push("routing");
-  if (type === "core-action") tags.push("runtime");
-  if (type === "human-input") tags.push("input");
-  if (action.includes("search") || action.includes("filter")) tags.push("evaluation", "guardrail");
-  if (action.includes("delete") || config?.confirmationRequired) tags.push("guardrail");
-  if (action.includes("http") || config?.url || config?.method) tags.push("routing", "input", "output");
-  if (action.includes("email")) tags.push("input", "output");
-  if (action.includes("delay") || config?.duration || config?.unit) tags.push("runtime");
-  if (config?.objectId || config?.fieldMap || config?.filters) tags.push("input", "output");
-  if (config?.model || config?.prompt) tags.push("model", "prompt");
-  return normalizeDeltaTags(tags);
-}
-
-function getNodeDeltaRecords(previousGraph, nextGraph) {
-  const previousNodes = new Map(
-    (Array.isArray(previousGraph?.nodes) ? previousGraph.nodes : [])
-      .map((node) => [String(node?.id || ""), node])
-      .filter(([id]) => id)
-  );
-
-  return (Array.isArray(nextGraph?.nodes) ? nextGraph.nodes : [])
-    .map((node) => {
-      const nodeId = String(node?.id || "").trim();
-      if (!nodeId) return null;
-      const previous = previousNodes.get(nodeId);
-      const config = node?.config && typeof node.config === "object" && !Array.isArray(node.config) ? node.config : {};
-      const previousConfig = previous?.config && typeof previous.config === "object" && !Array.isArray(previous.config)
-        ? previous.config
-        : {};
-      const currentComparable = JSON.stringify({
-        type: node?.type || "",
-        sandbox: node?.sandbox || "",
-        label: node?.label || "",
-        subtitle: node?.subtitle || "",
-        config
-      });
-      const previousComparable = JSON.stringify({
-        type: previous?.type || "",
-        sandbox: previous?.sandbox || "",
-        label: previous?.label || "",
-        subtitle: previous?.subtitle || "",
-        config: previousConfig
-      });
-      const explicitTags = normalizeDeltaTags(config.deltaTags);
-      const deltaTags = explicitTags.length > 0 ? explicitTags : inferDeltaTagsForWorkflowNode(node, config);
-      const changeReason = String(config.changeReason || "").trim();
-      const changed = currentComparable !== previousComparable;
-      if (!changed && !changeReason && deltaTags.length === 0) return null;
-      return {
-        nodeId,
-        nodeType: String(node?.type || ""),
-        label: String(node?.label || node?.sandbox || nodeId),
-        sandboxRecordRef: config.sandboxRecordRef || null,
-        changeReason,
-        deltaTags,
-        requiresRetest: config.requiresRetest !== false,
-        previous: previous ? {
-          type: String(previous.type || ""),
-          sandbox: String(previous.sandbox || ""),
-          label: String(previous.label || "")
-        } : null,
-        next: {
-          type: String(node.type || ""),
-          sandbox: String(node.sandbox || ""),
-          label: String(node.label || "")
-        }
-      };
-    })
-    .filter(Boolean);
-}
-
 function makeWorkflowNode(action, workspaceConfig, graph) {
   const baseId = String(action.id || action.type || "step").replace(/[^a-zA-Z0-9_-]+/g, "-");
   const existingIds = new Set((Array.isArray(graph?.nodes) ? graph.nodes : []).map((node) => String(node.id)));
@@ -606,54 +486,31 @@ export default function WorkflowSurface() {
 
   async function publishGraph() {
     if (resolved.rowIndex < 0 || !objectId) return;
+    // Publish is server-authoritative: POST /api/workspace/workflow/publish
+    // verifies the saved draft + passing test against the persisted row and
+    // owns the version bump, delta record, and draft → live promotion.
+    // Direct PATCH of live workflow fields is rejected by the runtime policy.
     const serialized = serializeCurrentGraph();
-    const draftPassed = sandboxRow?.orchestrationDraftTestPassed === true || String(sandboxRow?.orchestrationDraftTestPassed || "") === "true";
-    const testedConfig = String(sandboxRow?.orchestrationDraftTestedConfig || "");
-    if (!draftPassed || testedConfig !== serialized) {
-      setSaveMessage("Publish blocked. Save and test this exact draft successfully before publishing.");
+    const savedDraft = String(sandboxRow?.[draftFieldName] || "");
+    if (dirty || serialized !== savedDraft) {
+      setSaveMessage("Publish blocked. Save this draft first — publish promotes the saved, tested draft.");
       return;
     }
     setPublishing(true);
     setSaveMessage("");
     try {
-      const currentVersion = Number(sandboxRow?.version || 1);
-      const nextVersion = Number.isFinite(currentVersion) ? String(currentVersion + 1) : "1";
-      const previousDeltas = Array.isArray(sandboxRow?.orchestrationDeltas) ? sandboxRow.orchestrationDeltas : [];
-      const previousPublishedGraph = parseOrchestrationGraph(sandboxRow?.[effectiveFieldName]);
-      const graphWithRefs = withGraphSandboxRecordRefs(orchestrationGraph, objectId, rowId);
-      const nodeDeltas = getNodeDeltaRecords(previousPublishedGraph, graphWithRefs);
-      const deltaTags = normalizeDeltaTags(nodeDeltas.flatMap((delta) => delta.deltaTags));
-      const changeReason = nodeDeltas.map((delta) => delta.changeReason).filter(Boolean).join("\n");
-      const next = patchSandboxRowInConfig(workspaceConfig, objectId, resolved.rowIndex, {
-        [effectiveFieldName]: serialized,
-        [draftFieldName]: "",
-        version: nextVersion,
-        lifecycleStatus: "live",
-        orchestrationDraftStatus: "published",
-        orchestrationDraftTestPassed: false,
-        orchestrationDraftTestedConfig: "",
-        orchestrationPublishedAt: new Date().toISOString(),
-        orchestrationDeltas: [
-          ...previousDeltas,
-          {
-            at: new Date().toISOString(),
-            version: nextVersion,
-            field: effectiveFieldName,
-            action: "publish",
-            previousVersion: String(sandboxRow?.version || "1"),
-            draftTestedAt: sandboxRow?.orchestrationDraftLastTested || "",
-            draftRunId: sandboxRow?.orchestrationDraftLastRunId || "",
-            changeReason,
-            deltaTags,
-            nodeDeltas,
-            nodeCount: Array.isArray(orchestrationGraph?.nodes) ? orchestrationGraph.nodes.length : 0,
-            edgeCount: Array.isArray(orchestrationGraph?.edges) ? orchestrationGraph.edges.length : 0
-          }
-        ]
+      const res = await fetch("/api/workspace/workflow/publish", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ objectId, name: rowId, field: effectiveFieldName }),
       });
-      await persistWorkspace(next);
+      const payload = await res.json();
+      if (!res.ok || !payload.ok) {
+        throw new Error(payload.error || "Publish failed");
+      }
+      setWorkspaceConfig(payload.workspaceConfig || workspaceConfig);
       setDirty(false);
-      setSaveMessage(`Published orchestration config v${nextVersion}.`);
+      setSaveMessage(`Published orchestration config v${payload.version}.`);
     } catch (err) {
       setSaveMessage(err.message || "Publish failed");
     } finally {

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/orchestration-publish.js

@@ -0,0 +1,179 @@
+/**
+ * Orchestration publish helpers — shared by the Workflows surface (client)
+ * and POST /api/workspace/workflow/publish (server-authoritative publish).
+ *
+ * These were previously private functions inside app/workflows/WorkflowSurface.jsx.
+ * They are extracted so the *server* owns publish computation (version bump,
+ * delta records, draft → live promotion) and the client only renders state.
+ * Pure functions; the only dependency is the orchestration-graph parser.
+ */
+
+import { parseOrchestrationGraph } from "@/lib/orchestration-graph";
+
+function nodeSandboxRecordRef(objectId, rowName, nodeId) {
+  return {
+    objectId: String(objectId || "").trim(),
+    rowName: String(rowName || "").trim(),
+    nodeId: String(nodeId || "").trim()
+  };
+}
+
+function withGraphSandboxRecordRefs(graph, objectId, rowName) {
+  const parsed = parseOrchestrationGraph(graph) || graph;
+  if (!parsed || typeof parsed !== "object") return parsed;
+  return {
+    ...parsed,
+    nodes: (Array.isArray(parsed.nodes) ? parsed.nodes : []).map((node) => ({
+      ...node,
+      config: {
+        ...(node?.config || {}),
+        sandboxRecordRef: nodeSandboxRecordRef(objectId, rowName, node?.id)
+      }
+    }))
+  };
+}
+
+function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
+  const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  return {
+    ...workspaceConfig,
+    dataModel: {
+      ...workspaceConfig.dataModel,
+      objects: objects.map((object) => {
+        if (object?.id !== objectId) return object;
+        const rows = Array.isArray(object.rows) ? object.rows : [];
+        return {
+          ...object,
+          rows: rows.map((row, index) => (index === rowIndex ? { ...row, ...fields } : row)),
+        };
+      }),
+    },
+  };
+}
+
+function normalizeDeltaTags(tags) {
+  return Array.from(new Set((Array.isArray(tags) ? tags : [])
+    .map((tag) => String(tag || "").trim().toLowerCase())
+    .filter(Boolean)));
+}
+
+function inferDeltaTagsForWorkflowNode(node, config) {
+  const tags = [];
+  const type = String(node?.type || "").trim();
+  const action = String(config?.action || node?.id || "").trim();
+  if (type === "thinAdapter") tags.push("model", "prompt", "routing");
+  if (type === "ai-agent") tags.push("model", "prompt", "output");
+  if (type === "data-action" || type === "data-trigger") tags.push("input", "output");
+  if (type === "flow-control") tags.push("routing");
+  if (type === "core-action") tags.push("runtime");
+  if (type === "human-input") tags.push("input");
+  if (action.includes("search") || action.includes("filter")) tags.push("evaluation", "guardrail");
+  if (action.includes("delete") || config?.confirmationRequired) tags.push("guardrail");
+  if (action.includes("http") || config?.url || config?.method) tags.push("routing", "input", "output");
+  if (action.includes("email")) tags.push("input", "output");
+  if (action.includes("delay") || config?.duration || config?.unit) tags.push("runtime");
+  if (config?.objectId || config?.fieldMap || config?.filters) tags.push("input", "output");
+  if (config?.model || config?.prompt) tags.push("model", "prompt");
+  return normalizeDeltaTags(tags);
+}
+
+function getNodeDeltaRecords(previousGraph, nextGraph) {
+  const previousNodes = new Map(
+    (Array.isArray(previousGraph?.nodes) ? previousGraph.nodes : [])
+      .map((node) => [String(node?.id || ""), node])
+      .filter(([id]) => id)
+  );
+
+  return (Array.isArray(nextGraph?.nodes) ? nextGraph.nodes : [])
+    .map((node) => {
+      const nodeId = String(node?.id || "").trim();
+      if (!nodeId) return null;
+      const previous = previousNodes.get(nodeId);
+      const config = node?.config && typeof node.config === "object" && !Array.isArray(node.config) ? node.config : {};
+      const previousConfig = previous?.config && typeof previous.config === "object" && !Array.isArray(previous.config)
+        ? previous.config
+        : {};
+      const currentComparable = JSON.stringify({
+        type: node?.type || "",
+        sandbox: node?.sandbox || "",
+        label: node?.label || "",
+        subtitle: node?.subtitle || "",
+        config
+      });
+      const previousComparable = JSON.stringify({
+        type: previous?.type || "",
+        sandbox: previous?.sandbox || "",
+        label: previous?.label || "",
+        subtitle: previous?.subtitle || "",
+        config: previousConfig
+      });
+      const explicitTags = normalizeDeltaTags(config.deltaTags);
+      const deltaTags = explicitTags.length > 0 ? explicitTags : inferDeltaTagsForWorkflowNode(node, config);
+      const changeReason = String(config.changeReason || "").trim();
+      const changed = currentComparable !== previousComparable;
+      if (!changed && !changeReason && deltaTags.length === 0) return null;
+      return {
+        nodeId,
+        nodeType: String(node?.type || ""),
+        label: String(node?.label || node?.sandbox || nodeId),
+        sandboxRecordRef: config.sandboxRecordRef || null,
+        changeReason,
+        deltaTags,
+        requiresRetest: config.requiresRetest !== false,
+        previous: previous ? {
+          type: String(previous.type || ""),
+          sandbox: String(previous.sandbox || ""),
+          label: String(previous.label || "")
+        } : null,
+        next: {
+          type: String(node.type || ""),
+          sandbox: String(node.sandbox || ""),
+          label: String(node.label || "")
+        }
+      };
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Resolve which live field this row publishes into and which draft field
+ * feeds it.
+ *
+ * Precedence (matching the Workflows surface):
+ *   1. An explicit `requestedField` ("orchestrationConfig" | "orchestrationGraph")
+ *      — the surface preserves the URL-selected field when no live graph
+ *      exists yet, so the publish request may carry it.
+ *   2. Whichever live field is populated.
+ *   3. Whichever DRAFT field is populated — a row whose only state is
+ *      `orchestrationDraftGraph` publishes into `orchestrationGraph`,
+ *      never silently into `orchestrationConfig`.
+ *   4. Default `orchestrationConfig`.
+ */
+function resolveWorkflowFieldNames(row, requestedField) {
+  const hasGraphValue = (value) => Boolean(String(value ?? "").trim());
+  const draftFor = (live) => (live === "orchestrationConfig" ? "orchestrationDraftConfig" : "orchestrationDraftGraph");
+  if (requestedField === "orchestrationConfig" || requestedField === "orchestrationGraph") {
+    return { liveField: requestedField, draftField: draftFor(requestedField) };
+  }
+  let liveField;
+  if (hasGraphValue(row?.orchestrationConfig)) {
+    liveField = "orchestrationConfig";
+  } else if (hasGraphValue(row?.orchestrationGraph)) {
+    liveField = "orchestrationGraph";
+  } else if (!hasGraphValue(row?.orchestrationDraftConfig) && hasGraphValue(row?.orchestrationDraftGraph)) {
+    liveField = "orchestrationGraph";
+  } else {
+    liveField = "orchestrationConfig";
+  }
+  return { liveField, draftField: draftFor(liveField) };
+}
+
+export {
+  getNodeDeltaRecords,
+  inferDeltaTagsForWorkflowNode,
+  nodeSandboxRecordRef,
+  normalizeDeltaTags,
+  patchSandboxRowInConfig,
+  resolveWorkflowFieldNames,
+  withGraphSandboxRecordRefs
+};

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-activation.js

@@ -27,6 +27,10 @@
  *   - Backwards-compatible: a workspace with no `provenance` block still
  *     produces a valid (generic) activation state.
  *
+ * Sole import: lib/workspace-app-registry.js — the equally pure,
+ * dependency-free App Registry derivation module the Fleet lens reads
+ * (roadmap Item 4's runtime surface-metadata source).
+ *
  * The output shape:
  *
  *   {
@@ -54,6 +58,13 @@
  *   }
  */
 
+import {
+  APP_REGISTRY_OBJECT_ID,
+  deriveAppHealth,
+  deriveAppNextAction,
+  listAppSurfaceRows
+} from "./workspace-app-registry.js";
+
 const ACTIVATION_KIND = "growthub-workspace-activation-state-v1";
 const ACTIVATION_VERSION = 1;
 
@@ -1217,16 +1228,85 @@ function deriveAppBuildLensState(input = {}) {
   };
 }
 
+/**
+ * Fleet lens (roadmap Item 4 — now un-staged). The precondition named in
+ * docs/ROADMAP_IMPACT_ITEMS_V1.md is satisfied: the runtime surface-metadata
+ * source is the governed `workspace-app-registry` Data Model object
+ * (lib/workspace-app-registry.js). Each registered application derives one
+ * step: status from its health rollup (linked workflows/APIs/data sources +
+ * persistence/deploy flags), description from its computed next action, href
+ * into the real surface that unblocks it. Pure, no secrets, never throws.
+ */
+function deriveFleetLensState(input = {}) {
+  const cfg = isPlainObject(input?.workspaceConfig) ? input.workspaceConfig : {};
+  const records = isPlainObject(input?.workspaceSourceRecords) ? input.workspaceSourceRecords : {};
+  const dur = deriveRuntimeDurability(input?.metadataGraph);
+  const runtimeFlags = {
+    durable: dur.durable,
+    readOnly: dur.readOnly,
+    deployReady: deriveDeployLensState(input).complete
+  };
+
+  const rows = listAppSurfaceRows(cfg);
+  const steps = [];
+  if (rows.length === 0) {
+    steps.push({
+      id: "register-first-app",
+      label: "Register your first application surface",
+      description: `Create the ${APP_REGISTRY_OBJECT_ID} object (objectType "app-surface") and add one row per app — name, surfacePath, and refs to its dashboards/workflows/data sources/APIs.`,
+      status: "pending",
+      href: "/data-model",
+      cta: "Open Data Model",
+    });
+  }
+  for (const row of rows) {
+    const health = deriveAppHealth(cfg, records, row, runtimeFlags);
+    const next = deriveAppNextAction(row, health);
+    const appId = safeString(row.appId).trim() || safeString(row.Name).trim();
+    steps.push({
+      id: `app-${appId}`,
+      label: safeString(row.Name).trim(),
+      description: health.status === "ready"
+        ? `Healthy — ${health.linkedCount} linked object(s).`
+        : next.label,
+      status: health.status === "ready" ? "complete" : health.status === "blocked" ? "blocked" : "pending",
+      href: next.href,
+      hint: health.status === "blocked" ? health.blockers[0] : "",
+      cta: health.status === "ready" ? "Open app" : "Unblock app",
+    });
+  }
+  for (const step of steps) {
+    if (!step.hint) delete step.hint;
+  }
+
+  const { totalCount, completedCount, complete, nextStepId } = scoreLensSteps(steps);
+  const headline = rows.length === 0
+    ? "Register the applications this workspace operates."
+    : complete
+      ? `All ${rows.length} application(s) are healthy.`
+      : `Operating ${rows.length} application(s) — ${completedCount} healthy.`;
+  const nextStep = steps.find((s) => s.id === nextStepId);
+  return {
+    kind: LENS_STATE_KIND,
+    lensId: "fleet",
+    title: "Application fleet",
+    headline,
+    subheadline: complete
+      ? "Assign the next capability to an agent, or register another app."
+      : (nextStep ? `Next: ${nextStep.label}.` : "Resolve each app's blockers."),
+    complete,
+    completedCount,
+    totalCount,
+    nextStepId,
+    steps,
+  };
+}
+
 /**
  * The lens registry. The activation deriver is the `primary` lens (it keeps
  * its own v1 state kind for backwards compatibility); every other entry is a
  * secondary lens that plugs into the same panel and the same swarm packet.
  * Adding a roadmap item is "register a deriver" — no new surface.
- *
- * NB: a Fleet / multi-app lens (roadmap Item 4) is intentionally NOT registered
- * — the exported workspace runtime exposes no in-artifact multi-app surface
- * registry to derive from. See docs/ROADMAP_IMPACT_ITEMS_V1.md (it stays staged
- * until a runtime surface-metadata source exists).
  */
 const WORKSPACE_LENS_REGISTRY = [
   { id: "activation", title: "Activation", primary: true, derive: deriveWorkspaceActivationState },
@@ -1235,6 +1315,7 @@ const WORKSPACE_LENS_REGISTRY = [
   { id: "deploy", title: "Deploy readiness", primary: false, derive: deriveDeployLensState },
   { id: "tasks", title: "Task management", primary: false, derive: deriveTaskLensState },
   { id: "app-build", title: "Application buildout", primary: false, derive: deriveAppBuildLensState },
+  { id: "fleet", title: "Application fleet", primary: false, derive: deriveFleetLensState },
 ];
 
 function getLensEntry(lensId) {
@@ -1559,6 +1640,9 @@ export {
   deriveDeployLensState,
   deriveTaskLensState,
   deriveAppBuildLensState,
+  // Fleet / multi-app lens (roadmap Item 4 — derives from the governed
+  // workspace-app-registry object, lib/workspace-app-registry.js)
+  deriveFleetLensState,
   // Swarm-assignable condition packet (roadmap Item 8)
   deriveSwarmConditionPacket,
   // Workspace contribution graph (daily-ritual visualization)