@growthub/cli 0.13.8 → 0.14.0

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/settings/apps/page.jsx

@@ -3,6 +3,8 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { readWorkspaceConfig } from "@/lib/workspace-config";
 import { AppsList } from "./apps-list.jsx";
+import { CodexSitesDataModelCard } from "./codex-sites-data-model-card.jsx";
+import { SettingsAccordionGroup, SettingsAccordionSection } from "./settings-accordion-section.jsx";
 
 async function readForkMetadata() {
   try {
@@ -82,24 +84,39 @@ async function AppsSettingsPage() {
       <div className="workspace-settings-card-heading">
         <div>
           <h2>Apps</h2>
-          <p>Read-only workspace app, bridge, and fork metadata already available to this workspace.</p>
+          <p>Workspace apps discovered from the local apps directory and governed Data Model configuration.</p>
         </div>
       </div>
 
-      <section className="workspace-settings-section workspace-apps-linkage-section">
-        <h3>Workspace Linkage</h3>
-        <div className="workspace-settings-kv">
-          <span>Workspace</span><code>{workspaceConfig.id || "workspace-builder-default"}</code>
-          <span>Fork</span><code>{fork?.forkId || "local fork metadata unavailable"}</code>
-          <span>Kit</span><code>{fork?.kitId || workspaceConfig.provenance?.mirrors || "growthub-custom-workspace-starter-v1"}</code>
-          <span>Bridge</span><code>{bridge?.status || bridge?.id || "not connected"}</code>
-        </div>
-      </section>
+      <SettingsAccordionGroup defaultOpenId="workspace-apps">
+        <SettingsAccordionSection
+          id="workspace-apps"
+          title="Workspace Apps"
+          summary={`${apps.length} app${apps.length === 1 ? "" : "s"} discovered from directory and config.`}
+          className="workspace-apps-list-section"
+        >
+          <AppsList apps={apps} />
+        </SettingsAccordionSection>
+
+        <SettingsAccordionSection
+          id="workspace-linkage"
+          title="Workspace Linkage"
+          summary="Fork, kit, and bridge identity for this workspace."
+          className="workspace-apps-linkage-section"
+        >
+          <div className="workspace-settings-kv">
+            <span>Workspace</span><code>{workspaceConfig.id || "workspace-builder-default"}</code>
+            <span>Fork</span><code>{fork?.forkId || "local fork metadata unavailable"}</code>
+            <span>Kit</span><code>{fork?.kitId || workspaceConfig.provenance?.mirrors || "growthub-custom-workspace-starter-v1"}</code>
+            <span>Bridge</span><code>{bridge?.status || bridge?.id || "not connected"}</code>
+          </div>
+        </SettingsAccordionSection>
 
-      <section className="workspace-settings-section workspace-apps-list-section">
-        <h3>Workspace Apps</h3>
-        <AppsList apps={apps} />
-      </section>
+        <CodexSitesDataModelCard
+          apps={apps}
+          dataModel={workspaceConfig.dataModel || {}}
+        />
+      </SettingsAccordionGroup>
     </section>
   </SettingsShell>;
 }

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/app/settings/apps/settings-accordion-section.jsx

@@ -0,0 +1,50 @@
+"use client";
+
+import { createContext, useContext, useState } from "react";
+import { ChevronDown } from "lucide-react";
+
+const SettingsAccordionContext = createContext(null);
+
+function SettingsAccordionGroup({ defaultOpenId, children }) {
+  const [openId, setOpenId] = useState(defaultOpenId || null);
+  return <SettingsAccordionContext.Provider value={{ openId, setOpenId }}>
+    {children}
+  </SettingsAccordionContext.Provider>;
+}
+
+function SettingsAccordionSection({ id, title, summary, className = "", defaultOpen = false, children }) {
+  const group = useContext(SettingsAccordionContext);
+  const [localOpen, setLocalOpen] = useState(defaultOpen);
+  const open = group ? group.openId === id : localOpen;
+  const sectionClass = [
+    "workspace-settings-section",
+    "workspace-settings-accordion",
+    open ? "is-open" : "is-collapsed",
+    className
+  ].filter(Boolean).join(" ");
+  const toggle = () => {
+    if (group) {
+      group.setOpenId(open ? null : id);
+      return;
+    }
+    setLocalOpen((value) => !value);
+  };
+
+  return <section className={sectionClass}>
+    <button
+      type="button"
+      className="workspace-settings-accordion-trigger"
+      aria-expanded={open}
+      onClick={toggle}
+    >
+      <span>
+        <h3>{title}</h3>
+        {summary ? <em>{summary}</em> : null}
+      </span>
+      <ChevronDown size={16} aria-hidden="true" />
+    </button>
+    {open ? <div className="workspace-settings-accordion-body">{children}</div> : null}
+  </section>;
+}
+
+export { SettingsAccordionGroup, SettingsAccordionSection };

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

@@ -4,6 +4,7 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import Link from "next/link";
 import { useRouter, useSearchParams } from "next/navigation";
 import {
+  ArrowUpCircle,
   Bot,
   ChevronDown,
   ChevronUp,
@@ -51,7 +52,31 @@ import { AgentSwarmPanel } from "../data-model/components/AgentSwarmPanel.jsx";
 import { RunSetupPanel } from "./RunSetupPanel.jsx";
 import { describeRunInputMetadataItems, discoverRunInputSchema } from "@/lib/orchestration-run-inputs";
 import { selectWorkflowNodeInputSchema } from "@/lib/workspace-metadata-selectors";
-import { deriveProvenance, hasConnectionId } from "@/lib/workspace-activation";
+import { deriveProvenance, hasConnectionId, readUiCacheFlag } from "@/lib/workspace-activation";
+import { ApiRegistryCreationCockpit } from "../data-model/components/ApiRegistryCreationCockpit.jsx";
+import { deriveSandboxServerlessState } from "@/lib/sandbox-serverless-flow";
+import { deriveServerlessUpgradeState, SERVERLESS_UPGRADE_DISMISS_FLAG } from "@/lib/serverless-upgrade";
+
+// Set a flag on the governed workspace-ui-cache "activation" row (pure helper,
+// same transform the rail/lens one-time dismisses use).
+function withUiCacheFlag(workspaceConfig, flag, value) {
+  const dm = workspaceConfig?.dataModel && typeof workspaceConfig.dataModel === "object" ? workspaceConfig.dataModel : {};
+  const objects = Array.isArray(dm.objects) ? dm.objects : [];
+  const existing = objects.find((o) => o?.id === "workspace-ui-cache");
+  const baseRow = (existing?.rows || []).find((r) => r?.id === "activation") || { id: "activation" };
+  const nextRow = { ...baseRow, [flag]: value };
+  const nextCache = existing
+    ? { ...existing, rows: [nextRow, ...(existing.rows || []).filter((r) => r?.id !== "activation")] }
+    : {
+        id: "workspace-ui-cache", label: "Workspace UI Cache", source: "Workspace UI Cache",
+        objectType: "custom", columns: ["id", flag], rows: [nextRow],
+        binding: { mode: "manual", source: "Workspace UI Cache" },
+      };
+  const nextObjects = existing
+    ? objects.map((o) => (o?.id === "workspace-ui-cache" ? nextCache : o))
+    : [...objects, nextCache];
+  return { ...workspaceConfig, dataModel: { ...dm, objects: nextObjects } };
+}
 
 // Workspace Metadata Graph V1 — read-only dependency metadata for workflow
 // sidecars. The runtime path (sandbox-run, publish, draft/live) is
@@ -63,20 +88,33 @@ const WORKFLOW_METADATA_SELECTORS = Object.freeze({
 });
 
 function resolveRegistryRowForSandbox(workspaceConfig, sandboxRow) {
+  return resolveRegistryRefForSandbox(workspaceConfig, sandboxRow)?.row || null;
+}
+
+function resolveRegistryRefForSandbox(workspaceConfig, sandboxRow) {
   const graph = parseOrchestrationGraph(sandboxRow?.orchestrationConfig || sandboxRow?.orchestrationGraph);
   const apiNode = graph?.nodes?.find((n) => n?.type === "api-registry-call");
   const registryId = String(
     apiNode?.config?.registryId || apiNode?.config?.integrationId || sandboxRow?.schedulerRegistryId || ""
   ).trim();
-  if (!registryId || !workspaceConfig) return null;
+  if (!workspaceConfig) return null;
   const objects = Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+  let firstRegistryRow = null;
+  let firstRegistryObject = null;
   for (const objectItem of objects) {
     if (objectItem?.objectType !== "api-registry") continue;
     const rows = Array.isArray(objectItem.rows) ? objectItem.rows : [];
-    const match = rows.find((r) => String(r?.integrationId || "").trim() === registryId);
-    if (match) return match;
+    const firstRow = rows.find((r) => String(r?.integrationId || "").trim());
+    if (!firstRegistryRow && firstRow) {
+      firstRegistryRow = firstRow;
+      firstRegistryObject = objectItem;
+    }
+    if (registryId) {
+      const match = rows.find((r) => String(r?.integrationId || "").trim() === registryId);
+      if (match) return { object: objectItem, row: match };
+    }
   }
-  return null;
+  return firstRegistryRow ? { object: firstRegistryObject, row: firstRegistryRow } : null;
 }
 
 function patchSandboxRowInConfig(workspaceConfig, objectId, rowIndex, fields) {
@@ -349,6 +387,23 @@ export default function WorkflowSurface() {
   const [orchestrationGraph, setOrchestrationGraph] = useState(null);
   const [dirty, setDirty] = useState(false);
   const [runSetupOpen, setRunSetupOpen] = useState(false);
+  const [upgradeOpen, setUpgradeOpen] = useState(false);
+  const [serverlessSignals, setServerlessSignals] = useState({ configuredEnvRefs: [], persistenceAdapters: [] });
+
+  useEffect(() => {
+    let cancelled = false;
+    fetch("/api/workspace/env-status", { cache: "no-store" })
+      .then((res) => (res.ok ? res.json() : {}))
+      .then((payload) => {
+        if (cancelled) return;
+        setServerlessSignals({
+          configuredEnvRefs: Array.isArray(payload.configuredEnvRefs) ? payload.configuredEnvRefs : [],
+          persistenceAdapters: Array.isArray(payload.persistenceAdapters) ? payload.persistenceAdapters : [],
+        });
+      })
+      .catch(() => {});
+    return () => { cancelled = true; };
+  }, [objectId, rowId]);
 
   const load = useCallback(async () => {
     setLoading(true);
@@ -807,6 +862,73 @@ export default function WorkflowSurface() {
   const showSaveDraft = dirty && !graphUnset;
   const workflowModeLabel = isDraftMode ? "draft" : lifecycle || "live";
 
+  // Serverless upgrade — same derivation + cockpit as the sandbox/API lanes.
+  const upgradeState = deriveServerlessUpgradeState(workspaceConfig || {}, {
+    dismissed: readUiCacheFlag(workspaceConfig || {}, SERVERLESS_UPGRADE_DISMISS_FLAG),
+  });
+  const serverlessState = sandboxRow
+    ? deriveSandboxServerlessState({
+        sandboxRow,
+        workspaceConfig: workspaceConfig || {},
+        configuredEnvRefs: serverlessSignals.configuredEnvRefs,
+        persistenceAdapters: serverlessSignals.persistenceAdapters,
+      })
+    : null;
+  const isServerlessWorkflow = Boolean(serverlessState?.isServerless);
+
+  async function patchSandboxAndPersist(fields) {
+    if (resolved.rowIndex < 0 || !objectId || !workspaceConfig) return;
+    try {
+      const next = patchSandboxRowInConfig(workspaceConfig, objectId, resolved.rowIndex, fields);
+      await persistWorkspace(next);
+      setSaveMessage(fields.runLocality === "serverless"
+        ? "Upgraded to serverless. Link a scheduler and configure persistence to close the loop."
+        : fields.runLocality === "local"
+          ? "Reverted to local execution."
+          : "Saved.");
+    } catch (err) {
+      setSaveMessage(err.message || "Failed to save");
+    }
+  }
+
+  async function handleUpgradeAction(action) {
+    if (!action) return;
+    if (action.id === "toggle-locality") {
+      if (isServerlessWorkflow) {
+        await patchSandboxAndPersist({ runLocality: "local" });
+        return;
+      }
+      const registryRow = resolveRegistryRowForSandbox(workspaceConfig, sandboxRow);
+      const adapterId = String(sandboxRow?.adapter || "").trim();
+      await patchSandboxAndPersist({
+        runLocality: "serverless",
+        schedulerRegistryId: String(registryRow?.integrationId || "").trim(),
+        adapter: ["local-agent-host", "local-intelligence"].includes(adapterId) ? "local-process" : adapterId,
+      });
+    } else if (action.id === "open-settings") {
+      router.push(action.href || "/settings");
+    } else if (action.id === "link-scheduler") {
+      const registryRef = resolveRegistryRefForSandbox(workspaceConfig, sandboxRow);
+      if (registryRef?.object?.id && registryRef?.row?.integrationId) {
+        router.push(`/data-model?object=${encodeURIComponent(registryRef.object.id)}&row=${encodeURIComponent(registryRef.row.integrationId)}`);
+      } else {
+        router.push(`/data-model?object=${encodeURIComponent(objectId)}&row=${encodeURIComponent(rowId)}`);
+      }
+    } else if (action.id === "edit-adapter") {
+      // Full scheduler/adapter config lives on the sandbox object's drawer.
+      router.push(`/data-model?object=${encodeURIComponent(objectId)}&row=${encodeURIComponent(rowId)}`);
+    }
+  }
+
+  async function dismissUpgradeOnboarding() {
+    if (!workspaceConfig) return;
+    try {
+      await persistWorkspace(withUiCacheFlag(workspaceConfig, SERVERLESS_UPGRADE_DISMISS_FLAG, true));
+    } catch {
+      /* non-fatal */
+    }
+  }
+
   return (
     <main className="workspace-builder dm-workflow-page">
       <WorkspaceRail
@@ -854,6 +976,18 @@ export default function WorkflowSurface() {
             >
               <ChevronUp size={14} />
             </button>
+            {sandboxRow && (
+              <button
+                type="button"
+                className={"dm-workflow-icon-btn dm-workflow-upgrade-btn" + (isServerlessWorkflow ? " is-serverless" : (upgradeState.showOnboarding ? " is-pulse" : ""))}
+                aria-label={isServerlessWorkflow ? "Serverless workflow — review persistence & scheduling" : "Upgrade to serverless environment to ensure persistence"}
+                data-tooltip={isServerlessWorkflow ? "Serverless — review persistence & scheduling" : "Upgrade to serverless environment to ensure persistence"}
+                aria-pressed={upgradeOpen}
+                onClick={() => setUpgradeOpen((open) => !open)}
+              >
+                <ArrowUpCircle size={14} />
+              </button>
+            )}
             {showDiscardDraft && (
               <button
                 type="button"
@@ -920,6 +1054,43 @@ export default function WorkflowSurface() {
           </div>
         ) : null}
 
+        {/* One-time serverless upgrade onboarding — shows only when the operator
+            has workflows but none are serverless, and hasn't dismissed it. */}
+        {sandboxRow && !upgradeOpen && upgradeState.showOnboarding ? (
+          <div className="workspace-template-context-banner dm-workflow-upgrade-nudge" role="note">
+            <div>
+              <strong>{upgradeState.headline}</strong>
+              <span style={{ display: "block", marginTop: 2 }}>{upgradeState.subheadline}</span>
+            </div>
+            <div className="dm-workflow-upgrade-nudge-actions">
+              <button type="button" className="dm-btn-primary-sm" onClick={() => setUpgradeOpen(true)}>
+                <ArrowUpCircle size={13} /> Upgrade this workflow
+              </button>
+              <button type="button" className="dm-btn-ghost" onClick={dismissUpgradeOnboarding}>Not now</button>
+            </div>
+          </div>
+        ) : null}
+
+        {/* Serverless cockpit — same derivation + cockpit interface as the API
+            Registry and sandbox lanes. Toggles patch the sandbox row; deep config
+            (scheduler/adapter) routes to the object's Data Model drawer. */}
+        {sandboxRow && upgradeOpen && serverlessState ? (
+          <div className="dm-workflow-upgrade-panel">
+            <div className="dm-workflow-upgrade-panel-head">
+              <span className="dm-api-action-card-eyebrow">Persistence &amp; scheduling</span>
+              <button type="button" className="dm-workflow-icon-btn" aria-label="Close upgrade panel" onClick={() => { setUpgradeOpen(false); dismissUpgradeOnboarding(); }}>
+                <X size={14} />
+              </button>
+            </div>
+            <ApiRegistryCreationCockpit
+              state={serverlessState}
+              onAction={handleUpgradeAction}
+              disabled={saving || publishing || running}
+              eyebrow={isServerlessWorkflow ? "Serverless workflow" : "Upgrade to serverless"}
+            />
+          </div>
+        ) : null}
+
         {loading ? (
           <p className="dm-workflow-empty">Loading workflow…</p>
         ) : error ? (

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

@@ -45,6 +45,7 @@ import {
   Plus,
   Quote,
   RefreshCw,
+  Rocket,
   Rows3,
   Save,
   Search,
@@ -89,6 +90,11 @@ import {
 } from "@/lib/workspace-chart-values";
 import { selectObjectFilterableFields, selectObjectSortableFields } from "@/lib/workspace-metadata-selectors";
 import { deriveWorkspaceActivationState } from "@/lib/workspace-activation";
+import {
+  CODEX_SITES_OBJECT_ID,
+  ensureCodexSitesDataModel,
+  isCodexSiteUrl
+} from "@/lib/codex-sites-workspace-adapter";
 import { HelperSidecar } from "./data-model/components/HelperSidecar.jsx";
 import { WorkspaceRail } from "./workspace-rail.jsx";
 import { WorkspaceActivationPanel } from "./components/WorkspaceActivationPanel.jsx";
@@ -503,6 +509,34 @@ function listBuilderWorkflowItems(config) {
   });
 }
 
+function listBuilderSiteItems(config) {
+  const object = getDataModelObject(config, CODEX_SITES_OBJECT_ID);
+  const rows = Array.isArray(object?.rows) ? object.rows : [];
+  return rows.flatMap((row, index) => {
+    const url = String(row?.url || "").trim();
+    if (!isCodexSiteUrl(url)) return [];
+    const title = String(row?.Name || row?.name || `Codex Site ${index + 1}`).trim();
+    const rawStatus = String(row?.status || "").trim().toLowerCase();
+    const status = rawStatus === "active" ? "live" : rawStatus || "draft";
+    return [{
+      type: "site",
+      id: String(row?.id || row?.Name || `codex-site-${index + 1}`),
+      title,
+      itemKind: "Site",
+      updatedAt: formatBuilderTimestamp(row?.lastRecordedAt || ""),
+      status,
+      site: {
+        row,
+        rowIndex: index,
+        title,
+        url,
+        app: String(row?.app || "apps/workspace").trim(),
+        client: String(row?.client || "Workspace").trim()
+      }
+    }];
+  });
+}
+
 function formatBuilderTimestamp(value) {
   const raw = String(value || "").trim();
   if (!raw || raw === "new") return raw;
@@ -4246,6 +4280,7 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
   const canvas = config.canvas;
   const dashboards = config.dashboards || [];
   const workflows = useMemo(() => listBuilderWorkflowItems(config), [config]);
+  const sites = useMemo(() => listBuilderSiteItems(config), [config]);
   const builderItems = useMemo(() => {
     const dashboardItems = dashboards.map((dashboard, index) => ({
       type: "dashboard",
@@ -4266,13 +4301,17 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
       status: workflow.lifecycleStatus || "draft",
       workflow
     }));
+    const siteItems = sites.map((site) => ({
+      ...site,
+      updatedAt: site.updatedAt || "new"
+    }));
     const q = builderListFilter.query.trim().toLowerCase();
-    return [...dashboardItems, ...workflowItems].filter((item) => {
+    return [...dashboardItems, ...siteItems, ...workflowItems].filter((item) => {
       if (builderListFilter.type !== "all" && item.type !== builderListFilter.type) return false;
       if (!q) return true;
-      return [item.title, item.itemKind, item.status, item.type].some((part) => String(part || "").toLowerCase().includes(q));
+      return [item.title, item.itemKind, item.status, item.type, item.site?.client, item.site?.app, item.site?.url].some((part) => String(part || "").toLowerCase().includes(q));
     });
-  }, [builderListFilter, dashboards, workflows]);
+  }, [builderListFilter, dashboards, sites, workflows]);
   const resolvedActiveDashboardId = getActiveDashboardId(dashboards, activeDashboardId);
   const resolvedActiveDashboardIndex = activeDashboardIndex(dashboards, resolvedActiveDashboardId);
   const widgetTypes = config.widgetTypes;
@@ -4709,6 +4748,50 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
     }
   }, [config, saving]);
 
+  const createCodexSite = useCallback(async () => {
+    if (saving) return;
+    const objects = Array.isArray(config.dataModel?.objects) ? config.dataModel.objects : [];
+    const hasCodexSitesObject = objects.some((object) => object?.id === CODEX_SITES_OBJECT_ID);
+    if (hasCodexSitesObject) {
+      window.open(`/data-model?object=${encodeURIComponent(CODEX_SITES_OBJECT_ID)}`, "_self");
+      return;
+    }
+    const nextDataModel = ensureCodexSitesDataModel(config.dataModel, []);
+    setSaving(true);
+    try {
+      const response = await fetch("/api/workspace", {
+        method: "PATCH",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ dataModel: nextDataModel })
+      });
+      const payload = await response.json();
+      if (!response.ok || !payload.workspaceConfig) {
+        throw new Error(payload.error || "Failed to create Codex Sites object");
+      }
+      setConfig((prev) => ({ ...prev, dataModel: payload.workspaceConfig.dataModel }));
+      setBuilderListFilter({ type: "site", query: "" });
+      setConfigMessage("Created Codex Sites object");
+      window.open(`/data-model?object=${encodeURIComponent(CODEX_SITES_OBJECT_ID)}`, "_self");
+    } catch (error) {
+      setConfigMessage(error.message || "Failed to create Codex Sites object");
+    } finally {
+      setSaving(false);
+    }
+  }, [config, saving]);
+
+  const manageSite = useCallback((site) => {
+    const rowParam = site?.rowIndex !== undefined ? `&row=${encodeURIComponent(String(site.rowIndex))}` : "";
+    window.open(`/data-model?object=${encodeURIComponent(CODEX_SITES_OBJECT_ID)}${rowParam}`, "_self");
+  }, []);
+
+  const openSite = useCallback((site) => {
+    if (site?.url) {
+      window.open(site.url, "_blank", "noopener,noreferrer");
+      return;
+    }
+    manageSite(site);
+  }, [manageSite]);
+
   const selectDashboard = useCallback((index) => {
     setConfig((prev) => {
       const synced = syncActiveDashboard(prev, activeDashboardId);
@@ -5234,7 +5317,7 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
     }
     const rect = event.currentTarget.getBoundingClientRect();
     const menuWidth = 148;
-    const menuHeight = item?.type === "dashboard" ? 136 : 76;
+    const menuHeight = item?.type === "dashboard" ? 136 : item?.type === "site" ? 108 : 76;
     const margin = 8;
     const left = Math.min(
       Math.max(margin, rect.right - menuWidth),
@@ -5916,6 +5999,7 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
               </span>
             ) : null}
             <button type="button" onClick={addDashboard}><Plus size={15} />New Dashboard</button>
+            <button type="button" onClick={createCodexSite} disabled={saving}><Rocket size={15} />New Codex Site</button>
             <button type="button" onClick={createWorkflow} disabled={saving}><GitBranch size={15} />New Workflow</button>
             <button type="button" onClick={() => importInputRef.current?.click()}><Import size={15} />Import</button>
           </div>}
@@ -5952,13 +6036,14 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
         <section className="workspace-table" id="dashboards" aria-label="Builder">
           <div className="workspace-table-heading">
             <strong>Builder</strong>
-            <span>{dashboards.length} dashboard{dashboards.length === 1 ? "" : "s"} · {workflows.length} workflow{workflows.length === 1 ? "" : "s"}</span>
+            <span>{dashboards.length} dashboard{dashboards.length === 1 ? "" : "s"} · {sites.length} site{sites.length === 1 ? "" : "s"} · {workflows.length} workflow{workflows.length === 1 ? "" : "s"}</span>
           </div>
           <div className="workspace-builder-filterbar">
             <div className="workspace-builder-filterbar__segments" role="group" aria-label="Builder item type">
               {[
                 ["all", "All"],
                 ["dashboard", "Dashboards"],
+                ["site", "Sites"],
                 ["workflow", "Workflows"]
               ].map(([type, label]) => (
                 <button
@@ -6052,6 +6137,53 @@ function WorkspaceBuilder({ initialConfig, initialSourceRecords, adapterConfig,
                   </span>
                 )}
               </span>
+            </div> : item.type === "site" ? <div className="workspace-table-row" key={item.id}>
+              <span className="workspace-dashboard-title">
+                {item.site.url ? (
+                  <a href={item.site.url} target="_blank" rel="noreferrer">{item.title}</a>
+                ) : (
+                  <button
+                    className="active"
+                    onClick={() => manageSite(item.site)}
+                    type="button"
+                  >{item.title}</button>
+                )}
+              </span>
+              <span>{item.itemKind}</span>
+              <span>{item.updatedAt}</span>
+              <span>
+                <select
+                  aria-label={`Status for ${item.title}`}
+                  value={item.status || "draft"}
+                  disabled
+                >
+                  <option value="draft">draft</option>
+                  <option value="review">review</option>
+                  <option value="live">live</option>
+                  <option value="paused">paused</option>
+                </select>
+              </span>
+              <span className="workspace-dashboard-actions">
+                <button
+                  type="button"
+                  className="workspace-row-action-trigger"
+                  aria-label={`Actions for ${item.title}`}
+                  onClick={(event) => openBuilderActionMenu(item, event)}
+                >
+                  <MoreVertical size={16} aria-hidden="true" />
+                </button>
+                {builderActionMenuId === item.id && (
+                  <span className="workspace-row-action-menu" style={builderActionMenuPlacement || undefined}>
+                    {item.site.url ? (
+                      <a href={item.site.url} target="_blank" rel="noreferrer" onClick={closeBuilderActionMenu}>Open URL</a>
+                    ) : (
+                      <button type="button" disabled>Open URL</button>
+                    )}
+                    <button type="button" onClick={() => { closeBuilderActionMenu(); manageSite(item.site); }}>Manage</button>
+                    <button type="button" onClick={() => { closeBuilderActionMenu(); window.open("/settings/apps", "_self"); }}>Apps</button>
+                  </span>
+                )}
+              </span>
             </div> : <div className="workspace-table-row" key={item.id}>
               <span className="workspace-dashboard-title">
                 {editingWorkflowId === item.workflow.id ? <span className="workspace-dashboard-title-editor">

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/integrations/resolver-loader.js

@@ -28,11 +28,9 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 
 const staticLoaded = new Set();
-let staticLoadDone = false;
+const nativeImport = new Function("specifier", "return import(specifier)");
 
 async function loadStaticResolversOnce() {
-  if (staticLoadDone) return;
-  staticLoadDone = true;
   const resolversDir = path.resolve(/*turbopackIgnore: true*/ process.cwd(), "lib/adapters/integrations/resolvers");
   try {
     const entries = await fs.readdir(resolversDir);
@@ -42,7 +40,7 @@ async function loadStaticResolversOnce() {
         if (staticLoaded.has(file)) return;
         try {
           const absolutePath = path.join(resolversDir, file);
-          await import(/*turbopackIgnore: true*/ pathToFileURL(absolutePath).href);
+          await nativeImport(pathToFileURL(absolutePath).href);
           staticLoaded.add(file);
         } catch {
           // Malformed resolver — skip silently; operator needs to fix the file