@growthub/cli 0.14.2 → 0.14.4

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)