@nuasite/cms 0.42.1 → 0.43.0-beta.2

package/src/handlers/page-ops.ts

@@ -1,103 +1,12 @@
 import fs from 'node:fs/promises'
-import path from 'node:path'
-import { getProjectRoot } from '../config'
-import type { CreatePageRequest, DeletePageRequest, DuplicatePageRequest, LayoutInfo, PageOperationResponse } from '../types'
-import { escapeHtml, isNodeError, resolveAndValidatePath, slugify } from '../utils'
+import { resolveAndValidatePath, slugify } from '../utils'
 
 const PAGE_EXTENSIONS = ['.astro', '.md', '.mdx']
 
-export async function handleCreatePage(request: CreatePageRequest): Promise<PageOperationResponse> {
-	const { title, slug } = request
-	const normalizedSlug = slugify(slug || title)
-
-	if (!normalizedSlug) {
-		return { success: false, error: 'Could not generate a valid slug from the provided title/slug' }
-	}
-
-	const filePath = `src/pages/${normalizedSlug}.astro`
-	const fullPath = resolveAndValidatePath(filePath)
-
-	const layoutImport = await resolveLayoutImport(request.layoutPath)
-	const content = generatePageContent(title, layoutImport)
-
-	try {
-		await fs.mkdir(path.dirname(fullPath), { recursive: true })
-		// 'wx' flag atomically fails if file exists — no pre-check needed
-		await fs.writeFile(fullPath, content, { encoding: 'utf-8', flag: 'wx' })
-
-		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
-		return { success: true, filePath, slug: normalizedSlug, url }
-	} catch (error) {
-		if (isNodeError(error, 'EEXIST')) {
-			return { success: false, error: `Page already exists: ${filePath}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
-export async function handleDuplicatePage(request: DuplicatePageRequest): Promise<PageOperationResponse> {
-	const { sourcePagePath, slug, title } = request
-	const normalizedSlug = slugify(slug)
-
-	if (!normalizedSlug) {
-		return { success: false, error: 'Could not generate a valid slug' }
-	}
-
-	const sourceFile = await findPageFile(sourcePagePath)
-	if (!sourceFile) {
-		return { success: false, error: `Source page not found: ${sourcePagePath}` }
-	}
-
-	let content: string
-	try {
-		content = await fs.readFile(resolveAndValidatePath(sourceFile), 'utf-8')
-	} catch {
-		return { success: false, error: `Could not read source file: ${sourceFile}` }
-	}
-
-	if (title) {
-		content = replacePageTitle(content, title)
-	}
-
-	const newFilePath = `src/pages/${normalizedSlug}.astro`
-	const newFullPath = resolveAndValidatePath(newFilePath)
-
-	try {
-		await fs.mkdir(path.dirname(newFullPath), { recursive: true })
-		await fs.writeFile(newFullPath, content, { encoding: 'utf-8', flag: 'wx' })
-
-		const url = normalizedSlug === 'index' ? '/' : `/${normalizedSlug}`
-		return { success: true, filePath: newFilePath, slug: normalizedSlug, url }
-	} catch (error) {
-		if (isNodeError(error, 'EEXIST')) {
-			return { success: false, error: `Page already exists: ${newFilePath}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
-export async function handleDeletePage(request: DeletePageRequest): Promise<PageOperationResponse> {
-	const { pagePath } = request
-
-	const pageFile = await findPageFile(pagePath)
-	if (!pageFile) {
-		return { success: false, error: `Page not found: ${pagePath}` }
-	}
-
-	try {
-		// No pre-check — just unlink and handle ENOENT
-		await fs.unlink(resolveAndValidatePath(pageFile))
-		return { success: true, filePath: pageFile, url: pagePath }
-	} catch (error) {
-		if (isNodeError(error, 'ENOENT')) {
-			return { success: false, error: `File not found: ${pageFile}` }
-		}
-		return { success: false, error: errorMessage(error) }
-	}
-}
-
 /**
- * Reuses findPageFile to check whether a slug is already taken.
+ * Check whether a page slug is already taken. Page create/duplicate/delete and
+ * layout listing now live in `@nuasite/cms-core`; this slug check stays here
+ * because it is not part of the cms-core structural interface.
  */
 export async function handleCheckSlugExists(slug: string): Promise<{ exists: boolean; filePath?: string }> {
 	const normalizedSlug = slugify(slug)
@@ -107,35 +16,8 @@ export async function handleCheckSlugExists(slug: string): Promise<{ exists: boo
 	return found ? { exists: true, filePath: found } : { exists: false }
 }
 
-export async function handleGetLayouts(): Promise<LayoutInfo[]> {
-	const layoutsDir = path.join(getProjectRoot(), 'src', 'layouts')
-
-	let entries
-	try {
-		entries = await fs.readdir(layoutsDir, { withFileTypes: true })
-	} catch {
-		return []
-	}
-
-	const layouts: LayoutInfo[] = []
-	for (const entry of entries) {
-		if (entry.isFile() && entry.name.endsWith('.astro')) {
-			layouts.push({
-				name: path.basename(entry.name, '.astro'),
-				path: `src/layouts/${entry.name}`,
-			})
-		}
-	}
-
-	return layouts.sort((a, b) => a.name.localeCompare(b.name))
-}
-
 // --- Internal helpers ---
 
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error)
-}
-
 async function fileExists(fullPath: string): Promise<boolean> {
 	try {
 		await fs.access(fullPath)
@@ -160,70 +42,3 @@ async function findPageFile(pagePath: string): Promise<string | null> {
 
 	return null
 }
-
-async function resolveLayoutImport(layoutPath?: string): Promise<{ importPath: string; componentName: string } | null> {
-	if (layoutPath) {
-		const name = path.basename(layoutPath, '.astro')
-		const importPath = `../${layoutPath.replace(/^src\//, '')}`
-		return { importPath, componentName: pascalCase(name) }
-	}
-
-	const layouts = await handleGetLayouts()
-	if (layouts.length === 0) return null
-
-	const layout = layouts[0]!
-	const importPath = `../${layout.path.replace(/^src\//, '')}`
-	return { importPath, componentName: pascalCase(layout.name) }
-}
-
-function pascalCase(name: string): string {
-	return name.replace(/(^|[-_])(\w)/g, (_, _sep, char) => char.toUpperCase())
-}
-
-function generatePageContent(
-	title: string,
-	layoutImport: { importPath: string; componentName: string } | null,
-): string {
-	const escapedTitle = title.replace(/'/g, "\\'").replace(/`/g, '\\`')
-	const htmlTitle = escapeHtml(title)
-
-	if (layoutImport) {
-		const { importPath, componentName } = layoutImport
-		return `---
-import ${componentName} from '${importPath}'
----
-
-<${componentName} title="${escapedTitle}" description="">
-\t<main>
-\t\t<h1>${htmlTitle}</h1>
-\t</main>
-</${componentName}>
-`
-	}
-
-	return `---
-
----
-
-<html lang="en">
-\t<head>
-\t\t<meta charset="utf-8" />
-\t\t<meta name="viewport" content="width=device-width" />
-\t\t<title>${escapedTitle}</title>
-\t</head>
-\t<body>
-\t\t<main>
-\t\t\t<h1>${htmlTitle}</h1>
-\t\t</main>
-\t</body>
-</html>
-`
-}
-
-function replacePageTitle(content: string, newTitle: string): string {
-	let result = content
-	result = result.replace(/(title\s*=\s*")([^"]*)(")/, `$1${newTitle}$3`)
-	result = result.replace(/(<title>)([^<]*)(<\/title>)/, `$1${newTitle}$3`)
-	result = result.replace(/(<h1[^>]*>)([^<]*)(<\/h1>)/, `$1${escapeHtml(newTitle)}$3`)
-	return result
-}

package/src/index.ts

@@ -1,18 +1,20 @@
 import type { AstroIntegration } from 'astro'
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import fs from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
+import { createLocalStorageAdapter } from '@nuasite/cms-core'
 import { processBuildOutput } from './build-processor'
 import { scanCollections } from './collection-scanner'
 import { ComponentRegistry } from './component-registry'
 import { resetProjectRoot } from './config'
 import { createDevMiddleware } from './dev-middleware'
 import { getErrorCollector, resetErrorCollector } from './error-collector'
+import { ADMIN_ROUTE, createLocalAdminMiddleware } from './local-admin'
 import { ManifestWriter } from './manifest-writer'
-import { createLocalStorageAdapter } from './media/local'
 import type { MediaStorageAdapter } from './media/types'
+import { type CmsMode, resolveCmsMode } from './mode'
 import { rehypeCmsMarker } from './rehype-cms-marker'
 import type { CmsFeatures, CmsMarkerOptions, ComponentDefinition } from './types'
 import { createPublicStaticFileChecker } from './utils'
@@ -20,8 +22,18 @@ import { createVitePlugin } from './vite-plugin'
 
 export interface NuaCmsOptions extends CmsMarkerOptions {
 	/**
-	 * URL to the CMS editor script.
-	 * If not set, the built-in editor bundle is served from the dev server.
+	 * URL to the CMS editor (inline visual-editing widget) script.
+	 *
+	 * Resolution order in dev:
+	 * 1. this `src`, if set;
+	 * 2. the `NUA_CMS_EDITOR_SRC` environment variable (lets the host runtime point
+	 *    dev-preview at a specific CDN/local editor without a config change);
+	 * 3. the public CDN editor (`DEFAULT_CDN_EDITOR_SRC`) when a pre-built editor
+	 *    bundle ships with the package (the npm-installed case — e.g. a generated
+	 *    site's dev-preview), so the inline editor updates via a CDN push,
+	 *    independent of the site's `@nuasite/cms` version (matching hosting);
+	 * 4. the bundled editor served from the dev server, used only in the monorepo
+	 *    (no pre-built bundle) so editor source changes hot-reload.
 	 */
 	src?: string
 	/**
@@ -44,6 +56,22 @@ export interface NuaCmsOptions extends CmsMarkerOptions {
 		 */
 		siteTheme?: 'auto' | 'light' | 'dark'
 	}
+	/**
+	 * Run mode (cms-headless F7). Controls whether the plugin serves a local
+	 * full-page collections admin:
+	 *
+	 * - `local` (default for `pletivo dev` on a developer machine): lazily spawn an
+	 *   in-process cms-sidecar over the project's `node:fs` and serve the
+	 *   `@nuasite/collections-admin` SPA at `/_nua/admin`. The inline widget runs
+	 *   in-page as usual.
+	 * - `hosted` (inside the agent sandbox): a no-op for spawning/serving — the
+	 *   sidecar is a managed sandbox service and the admin is the webmaster tab.
+	 *   The plugin stays marker + CDN-inject only.
+	 *
+	 * Auto-detected from the environment when omitted (a sandbox env signal ⇒
+	 * `hosted`; otherwise `local`). An explicit value always wins.
+	 */
+	mode?: CmsMode
 	/**
 	 * Proxy /_nua/cms requests to this target URL during dev.
 	 * Example: 'http://localhost:8787'
@@ -88,6 +116,20 @@ const DEFAULT_MAX_UPLOAD_SIZE = 10 * 1024 * 1024
 
 const VIRTUAL_CMS_PATH = '/@nuasite/cms-editor.js'
 
+/**
+ * Virtual module id of the local `/_nua/admin` SPA entry (cms-headless F7). The
+ * HTML shell loads it as `<script type="module">`; the Vite plugin resolves it to
+ * `src/admin/entry.tsx` so the dev server transforms it (TSX → JS, real React).
+ */
+const VIRTUAL_ADMIN_ENTRY = '/@nuasite/cms-admin-entry.js'
+
+/**
+ * Public CDN editor script. Same URL hosting injects (see webmaster
+ * `packages/worker-hosting` `editorSrc`), so dev-preview and hosting load the
+ * identical inline editor and a CDN push updates both without touching the site.
+ */
+const DEFAULT_CDN_EDITOR_SRC = 'https://cdn.nuasite.com/script/latest/cms-editor.js'
+
 export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 	const {
 		// CMS editor options
@@ -111,6 +153,13 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 		maxUploadSize = DEFAULT_MAX_UPLOAD_SIZE,
 	} = options
 
+	// Run mode (cms-headless F7): `local` serves a full-page collections admin at
+	// /_nua/admin over an in-process sidecar; `hosted` (inside the agent sandbox)
+	// is a no-op for that — the managed sandbox sidecar + the webmaster tab own it.
+	// An explicit `options.mode` wins; otherwise auto-detect from the environment.
+	const mode = resolveCmsMode(options.mode)
+	const serveLocalAdmin = mode === 'local'
+
 	// When no proxy, enable local CMS API with default media adapter
 	const enableCmsApi = !proxy
 	const mediaAdapter = media ?? (enableCmsApi ? createLocalStorageAdapter() : undefined)
@@ -218,15 +267,41 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 				}
 
 				const vitePlugins: any[] = [...(createVitePlugin(pluginContext) as any)]
-				const cmsDir = !src ? dirname(fileURLToPath(import.meta.url)) : undefined
+				const cmsDir = dirname(fileURLToPath(import.meta.url))
+
+				// Local-mode (cms-headless F7): resolve the /_nua/admin SPA entry virtual
+				// module to src/admin/entry.tsx so Vite transforms it (TSX → JS, real
+				// React) and HMR works. The HTML shell loads this id as a module script.
+				if (serveLocalAdmin) {
+					vitePlugins.push({
+						name: 'nuasite-cms-admin-entry',
+						resolveId(id: string) {
+							if (id === VIRTUAL_ADMIN_ENTRY) {
+								return join(cmsDir, 'admin/entry.tsx')
+							}
+						},
+					})
+				}
 
 				// Detect pre-built editor bundle (present when installed from npm)
-				const editorBundlePath = cmsDir ? join(cmsDir, '../dist/editor.js') : undefined
-				const hasPrebuiltBundle = editorBundlePath ? existsSync(editorBundlePath) : false
+				const editorBundlePath = join(cmsDir, '../dist/editor.js')
+				const hasPrebuiltBundle = existsSync(editorBundlePath)
+
+				// Resolve which editor script dev-preview injects:
+				// 1. explicit `src`; 2. `NUA_CMS_EDITOR_SRC` env; 3. the public CDN editor
+				// when shipping a pre-built bundle (npm-installed site) — so dev-preview
+				// loads the same CDN editor as hosting and a CDN push updates it without a
+				// site rebuild; 4. the bundled source (monorepo only) for editor HMR.
+				const envSrc = process.env.NUA_CMS_EDITOR_SRC
+				const resolvedEditorSrc = src ?? envSrc ?? (hasPrebuiltBundle ? DEFAULT_CDN_EDITOR_SRC : VIRTUAL_CMS_PATH)
+
+				// Local virtual-module serving is only needed when injecting the bundled
+				// editor (the monorepo source path) — not for an external/CDN URL.
+				const servesBundledEditor = resolvedEditorSrc === VIRTUAL_CMS_PATH
 
 				// --- CMS Editor setup (dev only) ---
 				if (command === 'dev') {
-					const editorSrc = src ?? VIRTUAL_CMS_PATH
+					const editorSrc = resolvedEditorSrc
 
 					const configScript = `window.NuaCmsConfig = ${JSON.stringify(resolvedCmsConfig)};`
 
@@ -248,52 +323,32 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 					`,
 					)
 
-					if (!src) {
-						if (hasPrebuiltBundle) {
-							// Pre-built bundle exists (npm install case):
-							// Serve it via a virtual module — no JSX pragma, Tailwind, or aliases needed.
-							// Read on every load() so rebuilds during dev pick up without restarting
-							// the host (Astro, pletivo, etc).
-							vitePlugins.push({
-								name: 'nuasite-cms-editor',
-								resolveId(id: string) {
-									if (id === VIRTUAL_CMS_PATH) {
-										return VIRTUAL_CMS_PATH
-									}
-								},
-								load(id: string) {
-									if (id === VIRTUAL_CMS_PATH) {
-										return readFileSync(editorBundlePath!, 'utf-8')
-									}
-								},
-							})
-						} else {
-							// No pre-built bundle (monorepo dev case):
-							// Serve source files directly — Vite transforms TSX, resolves imports, HMR works.
-							vitePlugins.push({
-								name: 'nuasite-cms-editor',
-								resolveId(id: string) {
-									if (id === VIRTUAL_CMS_PATH) {
-										return join(cmsDir!, 'editor/index.tsx')
-									}
-								},
-							})
-
-							// Prepend @jsxImportSource pragma for editor .tsx files
-							// so Vite's esbuild uses Preact's h function
-							vitePlugins.push({
-								name: 'nuasite-cms-preact-jsx',
-								transform(code: string, id: string) {
-									if (id.includes('/src/editor/') && id.endsWith('.tsx') && !code.includes('@jsxImportSource')) {
-										return `/** @jsxImportSource preact */\n${code}`
-									}
-								},
-							})
-
-							// Add Tailwind CSS Vite plugin for editor styles
-							const tailwindcss = (await import('@tailwindcss/vite')).default
-							vitePlugins.push(tailwindcss())
-						}
+					if (servesBundledEditor) {
+						// Monorepo dev (no pre-built bundle): serve the editor source files
+						// directly so Vite transforms TSX, resolves imports, and HMR works.
+						vitePlugins.push({
+							name: 'nuasite-cms-editor',
+							resolveId(id: string) {
+								if (id === VIRTUAL_CMS_PATH) {
+									return join(cmsDir, 'editor/index.tsx')
+								}
+							},
+						})
+
+						// Prepend @jsxImportSource pragma for editor .tsx files
+						// so Vite's esbuild uses Preact's h function
+						vitePlugins.push({
+							name: 'nuasite-cms-preact-jsx',
+							transform(code: string, id: string) {
+								if (id.includes('/src/editor/') && id.endsWith('.tsx') && !code.includes('@jsxImportSource')) {
+									return `/** @jsxImportSource preact */\n${code}`
+								}
+							},
+						})
+
+						// Add Tailwind CSS Vite plugin for editor styles
+						const tailwindcss = (await import('@tailwindcss/vite')).default
+						vitePlugins.push(tailwindcss())
 					}
 				}
 
@@ -306,8 +361,9 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 					}
 				}
 
-				// Only add react->preact aliases when serving source files (not pre-built bundle)
-				const needsAliases = !src && !hasPrebuiltBundle
+				// Only add react->preact aliases when serving the editor source files
+				// (monorepo dev) — an external/CDN editor URL needs no module rewriting.
+				const needsAliases = servesBundledEditor
 
 				updateConfig({
 					markdown: {
@@ -349,6 +405,22 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 				if (enableCmsApi) {
 					logger.info('CMS API enabled at /_nua/cms/')
 				}
+
+				// Local-mode full-page collections admin (cms-headless F7). Registered
+				// only in `local` mode — in `hosted` (sandbox) this is a strict no-op:
+				// the managed sandbox sidecar (F2) + the webmaster tab (F3) own it.
+				// The in-process sidecar + SPA are built lazily on the first /_nua/admin
+				// hit, so dev startup stays fast. Media defaults to local public/uploads.
+				if (serveLocalAdmin) {
+					createLocalAdminMiddleware(server, {
+						contentDir,
+						componentDirs,
+						mediaAdapter: media ?? createLocalStorageAdapter(),
+						maxUploadSize,
+						entryModuleId: VIRTUAL_ADMIN_ENTRY,
+					})
+					logger.info(`CMS collections admin available at ${ADMIN_ROUTE}`)
+				}
 			},
 
 			'astro:build:done': async ({ dir, logger }) => {
@@ -391,12 +463,18 @@ async function mergeRedirects(dir: URL, logger: { info: (msg: string) => void })
 	logger.info(`Merged ${lineCount} CMS redirect(s) into _redirects`)
 }
 
+// Shared structural contract from @nuasite/cms-types — surfaced through the cms public API
+// so consumers of @nuasite/cms get the field-type list + guard from one place.
+export {
+	createContemberStorageAdapter as contemberMedia,
+	createLocalStorageAdapter as localMedia,
+	createS3StorageAdapter as s3Media,
+} from '@nuasite/cms-core'
+export { FIELD_TYPES, isFieldType } from '@nuasite/cms-types'
 export { n } from './field-types'
 export type { DateHints, ImageHints, NumberHints, TextareaHints, TextHints } from './field-types'
-export { createContemberStorageAdapter as contemberMedia } from './media/contember'
-export { createLocalStorageAdapter as localMedia } from './media/local'
-export { createS3StorageAdapter as s3Media } from './media/s3'
 export type { MediaFolderItem, MediaItem, MediaListOptions, MediaListResult, MediaStorageAdapter, MediaTypeFilter } from './media/types'
+export { type CmsMode, detectHostedFromEnv, resolveCmsMode } from './mode'
 export type { Color, Date, DateTime, Email, Image, Reference, Textarea, Time, Url } from './prop-types'
 
 export { scanCollections } from './collection-scanner'