@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.7

package/apps/client-cms-editor/backend/src/preview/bridge.ts

@@ -0,0 +1,79 @@
+import { selectCmsEditorTarget } from '../model';
+import type { CmsEditorSelection } from '../../../shared/cms/src/index';
+
+export const CMS_EDITOR_PREVIEW_TYPES = {
+  READY: 'cms:ready', SELECT: 'cms:select', SECTION_CLICK: 'cms:section-click', HIGHLIGHT: 'cms:highlight',
+  DESELECT: 'cms:deselect', SCROLL_TO: 'cms:scroll-to', SCROLL: 'cms:scroll', THEME_VARS: 'cms:theme-vars',
+  STYLE: 'cms:style', MODE: 'cms:preview-mode', REFRESH: 'cms:refresh',
+  /** Live storefront embed (?cms=1) — sectionKey matches assembled data-section-key */
+  SECTION_CLICKED: 'cms:section-clicked',
+  SELECT_SECTION: 'cms:select-section',
+  SECTIONS_READY: 'cms:sections-ready',
+} as const;
+
+export type CmsEditorPreviewMessage = {
+  type: string;
+  page_id?: string;
+  section_id?: string;
+  section_key?: string;
+  block_id?: string;
+  path?: string;
+  vars?: Record<string, unknown>;
+  css?: Record<string, unknown>;
+  mode?: string;
+  scroll_y?: number;
+};
+
+const VALID = new Set(Object.values(CMS_EDITOR_PREVIEW_TYPES));
+
+export function normalizeCmsEditorPreviewMessage(input: unknown): CmsEditorPreviewMessage | null {
+  if (!input || typeof input !== 'object') return null;
+  const row = input as Record<string, any>;
+  const type = String(row.type || '').trim();
+  if (!VALID.has(type as any)) return null;
+  const out: CmsEditorPreviewMessage = { type };
+  const pageId = String(row.page_id || row.pageId || '').trim();
+  const sectionId = String(row.section_id || row.sectionId || '').trim();
+  const sectionKey = String(row.section_key || row.sectionKey || '').trim();
+  const blockId = String(row.block_id || row.blockId || row.component_id || '').trim();
+  if (pageId) out.page_id = pageId;
+  if (sectionId) out.section_id = sectionId;
+  if (sectionKey) out.section_key = sectionKey;
+  if (blockId) out.block_id = blockId;
+  if (row.path != null) out.path = String(row.path);
+  if (row.vars && typeof row.vars === 'object') out.vars = row.vars;
+  if (row.css && typeof row.css === 'object') out.css = row.css;
+  if (row.mode != null) out.mode = String(row.mode);
+  if (row.scroll_y != null || row.scrollY != null) {
+    const n = Number(row.scroll_y ?? row.scrollY);
+    if (Number.isFinite(n)) out.scroll_y = n;
+  }
+  return out;
+}
+
+export function cmsEditorSelectionFromPreview(input: unknown, currentPageId: string | null = null): CmsEditorSelection | null {
+  const msg = normalizeCmsEditorPreviewMessage(input);
+  if (!msg) return null;
+  if (![
+    CMS_EDITOR_PREVIEW_TYPES.SELECT,
+    CMS_EDITOR_PREVIEW_TYPES.SECTION_CLICK,
+    CMS_EDITOR_PREVIEW_TYPES.SECTION_CLICKED,
+  ].includes(msg.type as any)) return null;
+  return selectCmsEditorTarget({
+    pageId: msg.page_id || currentPageId,
+    sectionId: msg.section_id || msg.section_key,
+    blockId: msg.block_id,
+    fieldPath: msg.path,
+  });
+}
+
+/** Tell the live storefront embed (?cms=1) which section key to outline. */
+export function postCmsEditorLiveSelect(target: Window | null | undefined, sectionKey: string) {
+  const key = String(sectionKey || '').trim();
+  if (!target || !key) return;
+  target.postMessage({ type: CMS_EDITOR_PREVIEW_TYPES.SELECT_SECTION, sectionKey: key }, '*');
+}
+
+export function postCmsEditorPreviewMessage(target: Window | null | undefined, message: CmsEditorPreviewMessage) {
+  target?.postMessage(message, '*');
+}

package/apps/client-cms-editor/backend/src/preview/urls.ts

@@ -0,0 +1,55 @@
+/**
+ * Studio canvas preview URLs — draft/live storefront with CMS embed markers.
+ * Domain must come from bootstrap / workspace context (never invent a host).
+ */
+
+export type CmsEditorPreviewMode = 'draft' | 'published' | 'live';
+
+export function cmsEditorSectionEmbedKey(section: { id?: string; name?: string; type?: string }) {
+  const raw = String(section?.name || section?.type || section?.id || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return raw || String(section?.id || 'section');
+}
+
+function normalizeHost(raw?: string | null) {
+  const host = String(raw || '')
+    .replace(/^https?:\/\//, '')
+    .replace(/\/$/, '')
+    .split('/')[0]
+    .trim()
+    .toLowerCase();
+  return host || null;
+}
+
+/**
+ * Build the URL the editor iframe should load for a real site preview.
+ * Returns null when no public domain is available — callers keep wireframe srcDoc.
+ */
+export function buildCmsEditorPagePreviewUrl(input: {
+  domain?: string | null;
+  routePath?: string | null;
+  pageId?: string | null;
+  mode?: CmsEditorPreviewMode;
+  revision?: number;
+}): string | null {
+  const host = normalizeHost(input.domain);
+  if (!host) return null;
+
+  let route = String(input.routePath || '/').trim() || '/';
+  if (!route.startsWith('/')) route = `/${route}`;
+  if (route.length > 1) route = route.replace(/\/+$/, '');
+
+  const url = new URL(`https://${host}${route}`);
+  const mode = input.mode || 'draft';
+  if (mode === 'draft') url.searchParams.set('preview', 'draft');
+  if (mode === 'published') url.searchParams.set('preview', 'published');
+  url.searchParams.set('cms', '1');
+  if (input.pageId) url.searchParams.set('page_id', String(input.pageId));
+  if (input.revision != null && Number.isFinite(Number(input.revision))) {
+    url.searchParams.set('_r', String(input.revision));
+  }
+  return url.toString();
+}

package/apps/client-cms-editor/backend/src/routing/cms-route.js

@@ -0,0 +1,293 @@
+/**
+ * Canonical CMS route semantics.
+ *
+ * The package itself owns /cms; consumers can explicitly provide another mount
+ * point only when they intentionally embed the package.
+ */
+
+export const DEFAULT_CMS_BASE_PATH = '/cms';
+
+export const CMS_RESERVED_SEGMENTS = new Set([
+  'sites',
+  'websites',
+  'editor',
+  'templates',
+  'imports',
+  'media',
+  'pages',
+  'studio',
+  'online-store',
+  'theme-editor',
+  'settings',
+  'preview',
+]);
+
+export const CMS_PANELS = new Set([
+  'pages',
+  'templates',
+  'imports',
+  'media',
+  'online-store',
+  'theme-editor',
+  'settings',
+  'preview',
+]);
+
+/**
+ * @param {any} value
+ * @returns {string | null}
+ */
+function clean(value) {
+  const text = value == null ? '' : String(value).trim();
+  return text || null;
+}
+
+/**
+ * @param {any} [basePath]
+ * @returns {string}
+ */
+function normalizeBasePath(basePath = DEFAULT_CMS_BASE_PATH) {
+  const raw = clean(basePath) || DEFAULT_CMS_BASE_PATH;
+  const withSlash = raw.startsWith('/') ? raw : `/${raw}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, '') : withSlash;
+}
+
+/**
+ * @param {any} searchParams
+ * @returns {URLSearchParams}
+ */
+function asSearchParams(searchParams) {
+  if (searchParams instanceof URLSearchParams) return searchParams;
+  if (typeof searchParams === 'string') {
+    return new URLSearchParams(searchParams.startsWith('?') ? searchParams.slice(1) : searchParams);
+  }
+  return new URLSearchParams(searchParams || undefined);
+}
+
+/**
+ * @param {URLSearchParams} searchParams
+ * @returns {string | null}
+ */
+function siteQuery(searchParams) {
+  return clean(
+    searchParams.get('site') ||
+      searchParams.get('project') ||
+      searchParams.get('project_slug'),
+  );
+}
+
+/**
+ * @param {{
+ *   view?: string;
+ *   siteSlug?: string | null;
+ *   pageId?: string | null;
+ *   panel?: string;
+ *   legacy?: boolean;
+ *   legacyTarget?: string | null;
+ * }} [params]
+ */
+function routeResult({
+  view = 'sites',
+  siteSlug = null,
+  pageId = null,
+  panel = 'pages',
+  legacy = false,
+  legacyTarget = null,
+} = {}) {
+  return {
+    view,
+    siteSlug: clean(siteSlug),
+    pageId: clean(pageId),
+    panel,
+    legacy: Boolean(legacy),
+    legacyTarget: clean(legacyTarget),
+  };
+}
+
+/**
+ * @param {string | null} [siteSlug]
+ * @param {{ basePath?: string }} [options]
+ * @returns {string}
+ */
+export function buildCmsHubPath(siteSlug = null, { basePath = DEFAULT_CMS_BASE_PATH } = {}) {
+  const base = normalizeBasePath(basePath);
+  const site = clean(siteSlug);
+  return site ? `${base}?site=${encodeURIComponent(site)}` : base;
+}
+
+/**
+ * @param {{ panel?: string; pageId?: string | null; siteSlug?: string | null }} [params]
+ * @param {{ basePath?: string }} [options]
+ * @returns {string}
+ */
+export function buildCmsPath(
+  { panel = 'pages', pageId = null, siteSlug = null } = {},
+  { basePath = DEFAULT_CMS_BASE_PATH } = {},
+) {
+  const base = normalizeBasePath(basePath);
+  const normalizedPanel = CMS_PANELS.has(panel) ? panel : 'pages';
+  const page = clean(pageId);
+  const site = clean(siteSlug);
+  const siteQs = site ? `?site=${encodeURIComponent(site)}` : '';
+
+  if (normalizedPanel === 'online-store') return `${base}/online-store${siteQs}`;
+  if (normalizedPanel === 'theme-editor') return `${base}/theme-editor${siteQs}`;
+  if (normalizedPanel === 'templates') return `${base}/templates${siteQs}`;
+  if (normalizedPanel === 'imports') return `${base}/imports${siteQs}`;
+  if (normalizedPanel === 'media') return `${base}/media${siteQs}`;
+  if (normalizedPanel === 'settings') return `${base}/settings${siteQs}`;
+  if (normalizedPanel === 'preview') return `${base}/preview${siteQs}`;
+  if (page) return `${base}/pages/${encodeURIComponent(page)}${siteQs}`;
+  return `${base}/pages${siteQs}`;
+}
+
+/**
+ * @param {any} [pathname]
+ * @param {any} [basePath]
+ * @returns {string[]}
+ */
+function cmsRest(pathname, basePath) {
+  const normalizedPath = `/${String(pathname || '').split('?')[0].split('#')[0].split('/').filter(Boolean).join('/')}`;
+  const base = normalizeBasePath(basePath);
+
+  if (normalizedPath === base) return [];
+  if (normalizedPath.startsWith(`${base}/`)) {
+    return normalizedPath.slice(base.length + 1).split('/').filter(Boolean);
+  }
+
+  // Compatibility for a CMS route mounted beneath an unknown host prefix.
+  const parts = normalizedPath.split('/').filter(Boolean);
+  const cmsIdx = parts.indexOf('cms');
+  return cmsIdx >= 0 ? parts.slice(cmsIdx + 1) : [];
+}
+
+/**
+ * @param {any} pathname
+ * @param {any} [searchParamsInput]
+ * @param {{ basePath?: string }} [options]
+ */
+export function parseCmsRoute(
+  pathname,
+  searchParamsInput,
+  { basePath = DEFAULT_CMS_BASE_PATH } = {},
+) {
+  const searchParams = asSearchParams(searchParamsInput);
+  const rest = cmsRest(pathname, basePath);
+  const siteFromQuery = siteQuery(searchParams);
+
+  if (rest.length === 0 || rest[0] === 'sites' || rest[0] === 'websites') {
+    return routeResult({
+      view: siteFromQuery ? 'hub' : 'sites',
+      siteSlug: siteFromQuery,
+      panel: 'pages',
+    });
+  }
+
+  // Legacy: /cms/editor?project=&page=
+  if (rest[0] === 'editor') {
+    const pageId = clean(searchParams.get('page'));
+    return routeResult({
+      view: 'pages',
+      siteSlug: siteFromQuery,
+      pageId,
+      panel: 'pages',
+      legacy: true,
+      legacyTarget: buildCmsPath(
+        { panel: 'pages', pageId, siteSlug: siteFromQuery },
+        { basePath },
+      ),
+    });
+  }
+
+  if (rest[0] === 'pages') {
+    const pageId = clean(rest[1] && rest[1] !== 'studio' ? rest[1] : searchParams.get('page'));
+    return routeResult({ view: 'pages', siteSlug: siteFromQuery, pageId, panel: 'pages' });
+  }
+
+  if (rest[0] === 'templates') {
+    return routeResult({
+      view: 'pages',
+      siteSlug: siteFromQuery,
+      pageId: searchParams.get('add_to_page'),
+      panel: 'templates',
+    });
+  }
+
+  if (rest[0] === 'imports') {
+    return routeResult({ view: 'pages', siteSlug: siteFromQuery, panel: 'imports' });
+  }
+
+  if (rest[0] === 'media') {
+    return routeResult({ view: 'media', siteSlug: siteFromQuery, panel: 'media' });
+  }
+
+  if (rest[0] === 'online-store') {
+    return routeResult({ view: 'online-store', siteSlug: siteFromQuery, panel: 'online-store' });
+  }
+
+  if (rest[0] === 'theme-editor') {
+    return routeResult({ view: 'theme-editor', siteSlug: siteFromQuery, panel: 'theme-editor' });
+  }
+
+  if (rest[0] === 'settings') {
+    return routeResult({ view: 'settings', siteSlug: siteFromQuery, panel: 'settings' });
+  }
+
+  if (rest[0] === 'preview') {
+    return routeResult({ view: 'preview', siteSlug: siteFromQuery, panel: 'preview' });
+  }
+
+  // Legacy slug-in-path: /cms/{slug}/pages[/:pageId]
+  const maybeSlug = clean(rest[0]);
+  if (maybeSlug && !CMS_RESERVED_SEGMENTS.has(maybeSlug)) {
+    const seg2 = rest[1];
+    const seg3 = rest[2];
+    let panel = 'pages';
+    let pageId = null;
+
+    if (seg2 === 'templates') {
+      panel = 'templates';
+      pageId = clean(searchParams.get('add_to_page'));
+    } else if (seg2 === 'imports') {
+      panel = 'imports';
+    } else if (!seg2 || seg2 === 'pages' || seg2 === 'studio') {
+      pageId = clean(seg3 || searchParams.get('page'));
+    }
+
+    return routeResult({
+      view: 'pages',
+      siteSlug: maybeSlug,
+      pageId,
+      panel,
+      legacy: true,
+      legacyTarget: buildCmsPath({ panel, pageId, siteSlug: maybeSlug }, { basePath }),
+    });
+  }
+
+  return routeResult({ view: 'sites', siteSlug: siteFromQuery, panel: 'pages' });
+}
+
+/**
+ * @param {any} pathname
+ * @param {any} [searchParams]
+ * @param {any} [options]
+ * @returns {boolean}
+ */
+export function isCmsStudioEditorRoute(pathname, searchParams, options) {
+  const parsed = parseCmsRoute(pathname, searchParams, options);
+  if (parsed.view === 'sites' || parsed.view === 'hub') return false;
+  return ['pages', 'theme-editor', 'online-store', 'media'].includes(parsed.view);
+}
+
+/**
+ * @param {any} pathname
+ * @param {any} [searchParams]
+ * @param {any} [options]
+ * @returns {boolean}
+ */
+export function isCmsEditorFullscreenRoute(pathname, searchParams, options) {
+  const parsed = parseCmsRoute(pathname, searchParams, options);
+  if (parsed.view === 'hub') return true;
+  if (parsed.view === 'sites' && parsed.siteSlug) return true;
+  return parsed.view !== 'sites';
+}

package/apps/client-cms-editor/backend/src/routing/index.js

@@ -0,0 +1,10 @@
+export {
+  DEFAULT_CMS_BASE_PATH,
+  CMS_RESERVED_SEGMENTS,
+  CMS_PANELS,
+  buildCmsHubPath,
+  buildCmsPath,
+  parseCmsRoute,
+  isCmsStudioEditorRoute,
+  isCmsEditorFullscreenRoute,
+} from './cms-route.js';

package/apps/client-cms-editor/backend/src/storefront.ts

@@ -0,0 +1,52 @@
+/**
+ * Portable storefront URL helpers — domain must come from bootstrap / workspace API.
+ * No slug-derived host guesses.
+ */
+
+export type StorefrontUrlInput = {
+  projectSlug?: string | null;
+  tenantDomain?: string | null;
+  publicDomain?: string | null;
+  siteDomain?: string | null;
+  path?: string;
+};
+
+function normalizePath(path?: string): string {
+  if (!path?.trim()) return '';
+  return path.startsWith('/') ? path : `/${path}`;
+}
+
+function normalizeHost(raw?: string | null): string | null {
+  const host = String(raw || '')
+    .replace(/^https?:\/\//, '')
+    .replace(/\/$/, '')
+    .split('/')[0]
+    .trim()
+    .toLowerCase();
+  return host || null;
+}
+
+export function resolveStorefrontUrl(input: StorefrontUrlInput): string | null {
+  const path = normalizePath(input.path);
+  for (const candidate of [input.siteDomain, input.publicDomain, input.tenantDomain]) {
+    if (!candidate?.trim()) continue;
+    const trimmed = candidate.trim();
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+      return `${trimmed.replace(/\/$/, '')}${path}`;
+    }
+    return `https://${trimmed.replace(/^\/\//, '')}${path}`;
+  }
+  const host = normalizeHost(input.tenantDomain);
+  if (!host) return null;
+  const route = path || '/';
+  return `https://${host}${route}`;
+}
+
+export function storefrontDisplayHost(url: string | null | undefined): string {
+  if (!url) return 'Domain not configured';
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}

package/apps/client-cms-editor/backend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "allowJs": true,
+    "checkJs": false,
+    "baseUrl": ".",
+    "paths": {
+      "@inneranimalmedia/agentsam-cms-shared": ["../shared/cms/src/index.ts"],
+      "@inneranimalmedia/agentsam-cms-shared/*": ["../shared/cms/src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/apps/client-cms-editor/backend/worker/index.js

@@ -0,0 +1,34 @@
+import appManifest from '../../agentsam.app.json';
+
+/**
+ * Canonical Cloudflare Worker boundary for Client CMS Editor.
+ *
+ * The current application backend is not yet Worker-native. This checked-in
+ * shell reserves the runtime boundary without silently pretending the Node or
+ * library backend has been ported. Wire application routes here as that work lands.
+ *
+ * Worker deployment name (wrangler) may differ from APP.id — never conflate them.
+ */
+const APP = Object.freeze(appManifest);
+
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+  });
+}
+
+export default {
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (request.method === "GET" && (url.pathname === "/health" || url.pathname === "/api/health")) {
+      return json({ ok: true, app: APP.id, runtime: "cloudflare-worker-scaffold" });
+    }
+    return json({
+      ok: false,
+      error: "worker_routes_not_wired",
+      app: APP.id,
+      note: "Canonical Worker boundary exists; application routes are not ported yet.",
+    }, 501);
+  },
+};

package/apps/client-cms-editor/backend/wrangler.jsonc

@@ -0,0 +1,11 @@
+{
+  "$schema": "../node_modules/wrangler/config-schema.json",
+  "name": "agentsam-client-cms-editor",
+  "main": "worker/index.js",
+  "compatibility_date": "2026-09-11",
+  "compatibility_flags": ["nodejs_compat"],
+  "workers_dev": false,
+  "observability": {
+    "enabled": true
+  }
+}