@inneranimalmedia/agentsam-sdk 2.6.4 → 2.6.7

package/apps/client-cms-editor/shared/cms/src/adapter.ts

@@ -0,0 +1,204 @@
+/**
+ * Portable CMS persistence/transport contract.
+ *
+ * The editor depends on this interface — not on any host's private CMS routes
+ * or invented Worker binding product sources. Hosts implement adapters:
+ *   - SQLite (desktop / offline authority)
+ *   - Cloudflare D1 + R2 (cloud authority via OAuth-proven resources)
+ *   - custom HTTP backend
+ *   - embedding application backends (one consumer implementation each)
+ *
+ * localStorage is never an adapter. It may cache UI chrome only.
+ *
+ * Required methods are authoring CRUD. Adapters that cannot support a method
+ * must throw a typed capability error — never silently drop editor actions.
+ */
+
+import type {
+  CmsEditorBlock,
+  CmsEditorPage,
+  CmsEditorSection,
+  CmsEditorSite,
+  CmsSiteCreateInput,
+  CmsSiteRecord,
+  CmsSiteUpdatePatch,
+} from './editor-types';
+import type { CmsPublicationSnapshot } from './publication';
+
+export type { CmsPublicationSnapshot } from './publication';
+
+export type CmsRevision = {
+  id: string;
+  pageId: string;
+  kind: 'draft' | 'publication';
+  createdAt: string;
+  label?: string;
+  snapshot?: unknown;
+};
+
+export type CmsAsset = {
+  id: string;
+  name: string;
+  mimeType?: string;
+  size?: number;
+  url?: string;
+  key?: string;
+  createdAt?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type CmsCapabilityErrorCode =
+  | 'cms_capability_unsupported'
+  | 'cms_adapter_not_configured'
+  | 'cms_source_not_found'
+  | 'cms_permission_denied';
+
+export class CmsCapabilityError extends Error {
+  readonly code: CmsCapabilityErrorCode;
+  readonly capability: string;
+
+  constructor(capability: string, message?: string, code: CmsCapabilityErrorCode = 'cms_capability_unsupported') {
+    super(message || `CMS adapter does not support ${capability}`);
+    this.name = 'CmsCapabilityError';
+    this.code = code;
+    this.capability = capability;
+  }
+}
+
+/**
+ * Required content-authoring contract for a real CMS editor.
+ * Optional methods must not be used as a way to dilute CRUD.
+ */
+export type CmsEditorAdapter = {
+  // Site lifecycle
+  listSites(): Promise<CmsSiteRecord[]>;
+  getSite(siteId: string): Promise<CmsSiteRecord>;
+  createSite(input: CmsSiteCreateInput): Promise<CmsSiteRecord>;
+  updateSite(siteId: string, patch: CmsSiteUpdatePatch): Promise<CmsSiteRecord>;
+  deleteSite(siteId: string): Promise<void>;
+  /** Hydrated aggregate (site metadata + page tree). */
+  loadSite(siteId: string): Promise<CmsEditorSite>;
+
+  // Pages
+  listPages(siteId: string): Promise<CmsEditorPage[]>;
+  getPage(pageId: string): Promise<CmsEditorPage>;
+  createPage(
+    siteId: string,
+    input: Partial<CmsEditorPage> & { title: string; slug: string },
+  ): Promise<CmsEditorPage>;
+  updatePage(pageId: string, patch: Partial<CmsEditorPage>): Promise<CmsEditorPage>;
+  deletePage(pageId: string): Promise<void>;
+
+  // Sections
+  listSections(pageId: string): Promise<CmsEditorSection[]>;
+  getSection(sectionId: string): Promise<CmsEditorSection>;
+  createSection(
+    pageId: string,
+    input: Partial<CmsEditorSection> & { name: string },
+  ): Promise<CmsEditorSection>;
+  updateSection(
+    sectionId: string,
+    patch: Partial<CmsEditorSection>,
+  ): Promise<CmsEditorSection>;
+  deleteSection(sectionId: string): Promise<void>;
+  reorderSections(pageId: string, sectionIds: string[]): Promise<void>;
+  setSectionVisibility(sectionId: string, visible: boolean): Promise<void>;
+
+  // Blocks
+  listBlocks(sectionId: string): Promise<CmsEditorBlock[]>;
+  getBlock(blockId: string): Promise<CmsEditorBlock>;
+  createBlock(
+    sectionId: string,
+    input: Partial<CmsEditorBlock> & { type: string },
+  ): Promise<CmsEditorBlock>;
+  updateBlock(
+    blockId: string,
+    patch: Partial<CmsEditorBlock>,
+  ): Promise<CmsEditorBlock>;
+  deleteBlock(blockId: string): Promise<void>;
+  reorderBlocks?(sectionId: string, blockIds: string[]): Promise<void>;
+
+  // Draft / revisions
+  saveDraft(pageId: string, payload: unknown): Promise<CmsRevision>;
+  getRevision(revisionId: string): Promise<CmsRevision>;
+  listRevisions(pageId: string): Promise<CmsRevision[]>;
+  restoreRevision(pageId: string, revisionId: string): Promise<CmsEditorPage>;
+
+  // Publication
+  previewDraft(pageId: string): Promise<{ previewUrl?: string; snapshot: unknown }>;
+  publish(pageId: string, options?: { revisionId?: string }): Promise<CmsPublicationSnapshot>;
+  getPublishedRevision(pageId: string): Promise<CmsPublicationSnapshot | null>;
+
+  // Assets
+  listAssets(siteId: string): Promise<CmsAsset[]>;
+  getAsset(assetId: string): Promise<CmsAsset>;
+  uploadAsset(
+    siteId: string,
+    file: Blob,
+    meta?: { name?: string; metadata?: Record<string, unknown> },
+  ): Promise<CmsAsset>;
+  updateAsset(
+    assetId: string,
+    patch: Partial<Pick<CmsAsset, 'name' | 'metadata' | 'url' | 'key'>>,
+  ): Promise<CmsAsset>;
+  deleteAsset(assetId: string): Promise<void>;
+};
+
+/** Capability ids used when reporting honest unsupported operations. */
+export const CMS_ADAPTER_CAPABILITIES = Object.freeze([
+  'listSites',
+  'getSite',
+  'createSite',
+  'updateSite',
+  'deleteSite',
+  'loadSite',
+  'listPages',
+  'getPage',
+  'createPage',
+  'updatePage',
+  'deletePage',
+  'listSections',
+  'getSection',
+  'createSection',
+  'updateSection',
+  'deleteSection',
+  'reorderSections',
+  'setSectionVisibility',
+  'listBlocks',
+  'getBlock',
+  'createBlock',
+  'updateBlock',
+  'deleteBlock',
+  'reorderBlocks',
+  'saveDraft',
+  'getRevision',
+  'listRevisions',
+  'restoreRevision',
+  'previewDraft',
+  'publish',
+  'getPublishedRevision',
+  'listAssets',
+  'getAsset',
+  'uploadAsset',
+  'updateAsset',
+  'deleteAsset',
+] as const);
+
+export type CmsAdapterCapability = (typeof CMS_ADAPTER_CAPABILITIES)[number];
+
+export type CmsAdapterKind = 'sqlite' | 'd1_r2' | 'http' | 'custom';
+
+export type CmsAdapterDescriptor = {
+  kind: CmsAdapterKind;
+  label: string;
+  /** Provenance of the backing store — never invented product resources. */
+  provenance: {
+    kind: 'native_runtime' | 'oauth_discovery' | 'user_configured' | 'http_endpoint';
+    runtimeId?: string;
+    connectionId?: string;
+    resourceId?: string;
+    endpoint?: string;
+  };
+  /** Explicit list of supported capabilities; omit only when fully implementing CmsEditorAdapter. */
+  capabilities?: CmsAdapterCapability[];
+};

package/apps/client-cms-editor/shared/cms/src/agent-context.ts

@@ -0,0 +1,37 @@
+import type { CmsAgentContext, CmsAgentContextProvider, CmsHostPrincipal } from './host';
+
+export type CmsAgentContextInput = {
+  principal: CmsHostPrincipal;
+  projectId: string;
+  route?: string;
+  pageId?: string | null;
+  sectionId?: string | null;
+  blockId?: string | null;
+  publicationRevision?: number | null;
+};
+
+export function createCmsAgentContext(input: CmsAgentContextInput): CmsAgentContext {
+  return {
+    surface: 'cms',
+    accountId: input.principal.accountId,
+    subjectId: input.principal.subjectId,
+    projectId: input.projectId,
+    metadata: {
+      route: input.route ?? null,
+      pageId: input.pageId ?? null,
+      sectionId: input.sectionId ?? null,
+      blockId: input.blockId ?? null,
+      publicationRevision: input.publicationRevision ?? null,
+    },
+  };
+}
+
+export function createCmsAgentContextProvider(
+  getInput: () => CmsAgentContextInput | Promise<CmsAgentContextInput>,
+): CmsAgentContextProvider {
+  return {
+    async getContext() {
+      return createCmsAgentContext(await getInput());
+    },
+  };
+}

package/apps/client-cms-editor/shared/cms/src/cloudflare-bindings.ts

@@ -0,0 +1,51 @@
+export type CmsCloudflareCapability =
+  | 'cms-cloud'
+  | 'iam'
+  | 'workers-ai'
+  | 'browser'
+  | 'container'
+  | 'encrypted-secrets'
+  | 'acp';
+
+export type CmsCloudflareBindingName =
+  | 'DB'
+  | 'WEBSITE_ASSETS'
+  | 'SESSION_CACHE'
+  | 'AGENTSAM_WAI'
+  | 'MY_CONTAINER'
+  | 'MYBROWSER'
+  | 'IAM_CLIENT_ID'
+  | 'IAM_CLIENT_SECRET'
+  | 'IAM_ORIGIN'
+  | 'SECRETS_ENCRYPTION_KEY'
+  | 'ACP_CLIENT_ID'
+  | 'ACP_CLIENT_SECRET';
+
+export type CmsCloudflareBindingContract = {
+  name: CmsCloudflareBindingName;
+  capability: CmsCloudflareCapability;
+  required: boolean;
+  secret?: boolean;
+  authority: 'metadata' | 'assets' | 'identity' | 'cache-only' | 'execution-only' | 'configuration';
+  description: string;
+};
+
+export const CMS_CLOUDFLARE_BINDINGS: readonly CmsCloudflareBindingContract[] = [
+  { name: 'DB', capability: 'cms-cloud', required: true, authority: 'metadata', description: 'D1 authority for CMS/account/publication metadata.' },
+  { name: 'WEBSITE_ASSETS', capability: 'cms-cloud', required: true, authority: 'assets', description: 'R2 storage for CMS-managed media, theme assets, generated artifacts and publication snapshots.' },
+  { name: 'SESSION_CACHE', capability: 'cms-cloud', required: false, authority: 'cache-only', description: 'Optional session/login acceleration cache. Never account or session authority.' },
+  { name: 'IAM_CLIENT_ID', capability: 'iam', required: true, authority: 'configuration', description: 'Public IAM client identifier.' },
+  { name: 'IAM_CLIENT_SECRET', capability: 'iam', required: true, secret: true, authority: 'identity', description: 'Confidential IAM client credential.' },
+  { name: 'IAM_ORIGIN', capability: 'iam', required: true, authority: 'identity', description: 'Canonical IAM issuer/auth-service origin, not the current website origin by default.' },
+  { name: 'AGENTSAM_WAI', capability: 'workers-ai', required: true, authority: 'execution-only', description: 'Workers AI binding when the user opts into Cloudflare AI.' },
+  { name: 'MYBROWSER', capability: 'browser', required: true, authority: 'execution-only', description: 'Optional Browser Rendering / browser automation binding.' },
+  { name: 'MY_CONTAINER', capability: 'container', required: true, authority: 'execution-only', description: 'Optional scoped execution runtime. It receives authenticated identity; it never establishes identity.' },
+  { name: 'SECRETS_ENCRYPTION_KEY', capability: 'encrypted-secrets', required: true, secret: true, authority: 'configuration', description: 'Envelope-encryption key only where application-managed encrypted secrets are persisted.' },
+  { name: 'ACP_CLIENT_ID', capability: 'acp', required: true, authority: 'configuration', description: 'ACP client identity when ACP is enabled.' },
+  { name: 'ACP_CLIENT_SECRET', capability: 'acp', required: true, secret: true, authority: 'configuration', description: 'ACP confidential credential when ACP is enabled.' },
+] as const;
+
+export function cmsBindingsForCapabilities(capabilities: Iterable<CmsCloudflareCapability>) {
+  const enabled = new Set(capabilities);
+  return CMS_CLOUDFLARE_BINDINGS.filter((binding) => enabled.has(binding.capability));
+}

package/apps/client-cms-editor/shared/cms/src/editor-types.ts

@@ -0,0 +1,90 @@
+export type CmsEditorZone = 'HEADER' | 'BODY' | 'FOOTER' | 'TEMPLATE';
+export type CmsEditorStatus = 'live' | 'draft' | 'new';
+export type CmsEditorTargetKind = 'page' | 'section' | 'block';
+
+export type CmsEditorBlock = {
+  id: string;
+  sectionId: string;
+  type: string;
+  visible: boolean;
+  data: Record<string, any>;
+  sortOrder: number;
+};
+
+export type CmsEditorSection = {
+  id: string;
+  name: string;
+  type: string;
+  zone: CmsEditorZone;
+  visible: boolean;
+  color: string;
+  fields: Record<string, any>;
+  css?: Record<string, any>;
+  blocks: CmsEditorBlock[];
+};
+
+export type CmsEditorPage = {
+  id: string;
+  title: string;
+  slug: string;
+  status: CmsEditorStatus;
+  type: string;
+  parent?: string;
+  sections: CmsEditorSection[];
+  metaTitle: string;
+  metaDescription: string;
+};
+
+export type CmsEditorSiteTheme = {
+  cssVars: Record<string, string>;
+};
+
+export type CmsEditorSiteSchemas = {
+  protocol_version: number;
+  sections: unknown[];
+  blocks: unknown[];
+  fields?: unknown[];
+};
+
+export type CmsEditorSite = {
+  id: string;
+  name: string;
+  initials: string;
+  domain: string;
+  edited: string;
+  color: string;
+  pages: CmsEditorPage[];
+  /** Site-level theme authority (starter pack + editor). */
+  theme?: CmsEditorSiteTheme;
+  /** Site-level schema registry (starter pack + editor). */
+  schemas?: CmsEditorSiteSchemas;
+};
+
+/** Site metadata without hydrated page trees (aggregate reads use loadSite). */
+export type CmsSiteRecord = Omit<CmsEditorSite, 'pages'>;
+
+export type CmsSiteCreateInput = {
+  id?: string;
+  name: string;
+  domain?: string;
+  initials?: string;
+  color?: string;
+  theme?: CmsEditorSiteTheme;
+  schemas?: CmsEditorSiteSchemas;
+};
+
+export type CmsSiteUpdatePatch = Partial<
+  Pick<CmsEditorSite, 'name' | 'initials' | 'domain' | 'edited' | 'color' | 'theme' | 'schemas'>
+>;
+
+export type CmsEditorSelection = {
+  kind: CmsEditorTargetKind;
+  pageId: string | null;
+  sectionId: string | null;
+  blockId: string | null;
+  fieldPath: string | null;
+};
+
+export const emptyCmsEditorSelection = (): CmsEditorSelection => ({
+  kind: 'page', pageId: null, sectionId: null, blockId: null, fieldPath: null,
+});

package/apps/client-cms-editor/shared/cms/src/host.ts

@@ -0,0 +1,82 @@
+/**
+ * Optional capabilities supplied by the embedding host.
+ * The CMS remains independent of host navigation,
+ * identity authority, runtime, and deployment topology.
+ */
+
+/** Minimal authenticated identity the CMS needs for context metadata. */
+export type CmsHostPrincipal = {
+  /** Host-stable subject identifier (consumer maps its own user id here). */
+  subjectId: string;
+  accountId?: string;
+  displayName?: string;
+  email?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type CmsAgentSurfaceKind = 'cms' | string;
+
+/** Explicit CMS selection context passed to an optional agent host. */
+export type CmsAgentContext = {
+  surface: CmsAgentSurfaceKind;
+  accountId?: string;
+  subjectId?: string;
+  projectId?: string;
+  metadata?: {
+    route?: string | null;
+    pageId?: string | null;
+    sectionId?: string | null;
+    blockId?: string | null;
+    publicationRevision?: number | null;
+    [key: string]: unknown;
+  };
+};
+
+export type CmsAgentContextProvider = {
+  getContext(): CmsAgentContext | Promise<CmsAgentContext>;
+};
+
+/** Opaque annotation payload from a host mini-agent. */
+export type CmsAnnotationSelection = {
+  id?: string;
+  label?: string;
+  [key: string]: unknown;
+};
+
+export type CmsAgentDrawerSlotProps = {
+  open: boolean;
+  onClose: () => void;
+  projectId: string;
+  conversationId: string;
+  contextProvider: CmsAgentContextProvider;
+  route?: string;
+  pageId?: string | null;
+  sectionId?: string | null;
+  blockId?: string | null;
+  selectionLabel?: string | null;
+  pendingPrompt?: string | null;
+  onPendingPromptConsumed?: () => void;
+};
+
+export type CmsAgentMiniSlotProps = {
+  projectId: string;
+  conversationId: string;
+  contextProvider: CmsAgentContextProvider;
+  annotateSelecting?: boolean;
+  onAnnotateToggle?: () => void;
+  onAnnotateSubmit?: (
+    prompt: string,
+    annotation: CmsAnnotationSelection,
+  ) => void | Promise<void>;
+};
+
+/**
+ * Host/deployment capabilities supplied by the embedding application.
+ * Consumers implement these — the CMS package does not hardcode navigation or identity.
+ */
+export type CmsEditorHost = {
+  principal?: CmsHostPrincipal | null;
+  navigate?: (path: string) => void;
+  openExternal?: (url: string) => void;
+  labelTemporaryAdapter?: (message: string) => void;
+};

package/apps/client-cms-editor/shared/cms/src/index.ts

@@ -0,0 +1,9 @@
+export * from './editor-types';
+export * from './publication';
+export * from './cloudflare-bindings';
+export * from './agent-context';
+export * from './host';
+export * from './routes';
+export * from './adapter';
+export * from './map';
+export * from './starter-pack';

package/apps/client-cms-editor/shared/cms/src/map.ts

@@ -0,0 +1,115 @@
+import type { CmsEditorBlock, CmsEditorPage, CmsEditorSection, CmsEditorSelection, CmsEditorSite } from './editor-types';
+
+type Json = Record<string, any>;
+
+export function parseCmsEditorObject(value: unknown): Record<string, any> {
+  if (!value) return {};
+  if (typeof value === 'object') return value as Record<string, any>;
+  try { return JSON.parse(String(value)); } catch { return {}; }
+}
+
+export function cmsEditorInitials(name: string) {
+  return name.split(/\s+/).filter(Boolean).slice(0, 2).map((part) => part[0]).join('').toUpperCase() || 'CMS';
+}
+
+function zoneFor(row: Json): CmsEditorSection['zone'] {
+  const fields = parseCmsEditorObject(row.section_data ?? row.data ?? row.fields);
+  const explicit = String(row.zone || fields.zone || '').toUpperCase();
+  if (explicit === 'HEADER' || explicit === 'FOOTER' || explicit === 'TEMPLATE') return explicit;
+  const type = String(row.section_type || row.type || '').toLowerCase();
+  if (type.includes('nav') || type.includes('header')) return 'HEADER';
+  if (type.includes('footer')) return 'FOOTER';
+  return 'BODY';
+}
+
+export function mapCmsEditorBlock(row: Json, sectionId = ''): CmsEditorBlock {
+  const data = parseCmsEditorObject(row.block_data ?? row.component_data ?? row.data);
+  return {
+    id: String(row.id || ''),
+    sectionId: String(row.section_id || row.sectionId || sectionId || ''),
+    type: String(row.block_type || row.component_type || row.type || 'block'),
+    visible: row.is_visible === undefined ? row.visible !== false : Boolean(Number(row.is_visible)),
+    data,
+    sortOrder: Number(row.sort_order || 0),
+  };
+}
+
+export function mapCmsEditorSection(row: Json, blocks: CmsEditorBlock[] = []): CmsEditorSection {
+  const fields = parseCmsEditorObject(row.section_data ?? row.data ?? row.fields);
+  return {
+    id: String(row.id || ''),
+    name: String(row.section_name || row.name || row.section_type || row.type || 'Section'),
+    type: String(row.section_type || row.type || fields.section_type || 'section'),
+    zone: zoneFor({ ...row, section_data: fields }),
+    visible: row.is_visible === undefined ? row.visible !== false : Boolean(Number(row.is_visible)),
+    color: String(fields.bg_color || fields.background_color || row.color || '#111115'),
+    fields,
+    css: parseCmsEditorObject(fields.css_override || row.css),
+    blocks,
+  };
+}
+
+export function mapCmsEditorPage(row: Json, sections: CmsEditorSection[] = []): CmsEditorPage {
+  const route = String(row.route_path || row.slug || '/');
+  return {
+    id: String(row.id || ''),
+    title: String(row.title || row.slug || 'Untitled'),
+    slug: route.startsWith('/') ? route : `/${route}`,
+    status: row.status === 'published' || row.is_published ? 'live' : row.status === 'new' ? 'new' : 'draft',
+    type: String(row.page_type || row.type || (route === '/' ? 'Home' : 'Interior')),
+    parent: row.parent_id || undefined,
+    sections,
+    metaTitle: String(row.seo_title || row.meta_title || row.title || ''),
+    metaDescription: String(row.meta_description || ''),
+  };
+}
+
+export function mapCmsEditorBootstrap(raw: Json, projectSlug: string) {
+  const sectionsByPage = raw.sections_by_page || {};
+  const blocksBySection = raw.blocks_by_section || raw.components_by_section || {};
+  const pages = (raw.pages || []).map((page: Json) => {
+    const sections = (sectionsByPage[page.id] || []).map((section: Json) => {
+      const blocks = (blocksBySection[section.id] || []).map((row: Json) => mapCmsEditorBlock(row, section.id));
+      return mapCmsEditorSection(section, blocks);
+    });
+    return mapCmsEditorPage(page, sections);
+  });
+  const tenant = raw.tenant || {};
+  const name = String(tenant.name || raw.workspace_label || projectSlug || 'CMS Site');
+  const themeVars = parseCmsEditorObject(raw.active_theme?.css_vars || raw.active_theme?.css_vars_json);
+  const site: CmsEditorSite = {
+    id: projectSlug,
+    name,
+    initials: cmsEditorInitials(name),
+    domain: String(raw.public_domain || tenant.domain || ''),
+    edited: 'Just now',
+    color: String(themeVars['--brand-primary'] || tenant.primary_color || '#6358ff'),
+    pages,
+  };
+  return {
+    site,
+    themeVars,
+    templates: raw.component_templates || [],
+    imports: raw.liquid_imports || [],
+    homePageId: raw.home_page?.id || pages[0]?.id || null,
+    schemas: {
+      protocol_version: Number(raw.protocol_version || raw.schemas?.protocol_version || 1),
+      sections: Array.isArray(raw.schemas?.sections) ? raw.schemas.sections : [],
+      blocks: Array.isArray(raw.schemas?.blocks) ? raw.schemas.blocks : [],
+      fields: Array.isArray(raw.schemas?.fields) ? raw.schemas.fields : [],
+    },
+  };
+}
+
+export function selectCmsEditorTarget(input: Partial<CmsEditorSelection> & { kind?: CmsEditorSelection['kind'] }): CmsEditorSelection {
+  const sectionId = String(input.sectionId || '').trim() || null;
+  const blockId = String(input.blockId || '').trim() || null;
+  const pageId = String(input.pageId || '').trim() || null;
+  return {
+    kind: input.kind || (blockId ? 'block' : sectionId ? 'section' : 'page'),
+    pageId,
+    sectionId,
+    blockId,
+    fieldPath: String(input.fieldPath || '').trim() || null,
+  };
+}

package/apps/client-cms-editor/shared/cms/src/publication.ts

@@ -0,0 +1,24 @@
+export type CmsSectionPayload = {
+  id?: string;
+  type: string;
+  props: Record<string, unknown>;
+};
+
+export type CmsPublicationSnapshot = {
+  publicationId: string;
+  route: string;
+  revision: number;
+  theme: string;
+  sections: CmsSectionPayload[];
+  publishedAt?: string;
+  metadata?: Record<string, unknown>;
+};
+
+export type CmsPublishedAsset = {
+  id: string;
+  key: string;
+  mimeType: string;
+  size?: number;
+  url?: string;
+  metadata?: Record<string, unknown>;
+};

package/apps/client-cms-editor/shared/cms/src/routes.ts

@@ -0,0 +1,11 @@
+export const CMS_ROUTE_BOUNDARIES = Object.freeze({
+  public: '/*',
+  auth: '/auth/*',
+  dashboard: '/dashboard/*',
+  agentsam: '/agentsam',
+  cms: '/cms',
+  publicApi: '/api/public/*',
+  authApi: '/api/auth/*',
+  cmsApi: '/api/cms/*',
+  agentsamApi: '/api/agentsam/*',
+});