@o-a/cms-agent 0.1.6 → 0.2.0

package/dist/server.js

@@ -2,10 +2,12 @@ import rateLimitPlugin from '@fastify/rate-limit';
 import Fastify, {} from 'fastify';
 import { bootSite } from "./boot.js";
 import { loadServerConfig } from "./server-config.js";
+import { adminRedirectRoutes } from "./routes/admin-redirect.js";
 import { assetsRoutes } from "./routes/assets.js";
 import { v1Routes } from "./routes/index.js";
 import { mediaPublicRoutes } from "./routes/media-public.js";
 import { publicRoutes } from "./routes/public.js";
+import { searchPublicRoutes } from "./routes/search-public.js";
 import { sitemapRoutes } from "./routes/sitemap.js";
 import { CHECKPOINT_AUTHOR, runCheckpoint } from "./services/checkpoint.js";
 import { startDevTunnel } from "./services/dev-tunnel.js";
@@ -76,6 +78,7 @@ export function buildServer(booted, serverConfig, options = {}) {
         themeTemplates: booted.themeTemplates,
         layouts: booted.layouts,
         engine: booted.engine,
+        renderCache: booted.renderCache,
     });
     // A more specific static-prefixed route than the public catch-all's
     // own /* wildcard - Fastify prefers it regardless of registration
@@ -98,6 +101,25 @@ export function buildServer(booted, serverConfig, options = {}) {
     // also always wins over a same-named static file under
     // theme/root/sitemap.xml (see routes/public.ts's root-mirror check).
     app.register(sitemapRoutes, { config: booted.config });
+    // Same "more specific than the public catch-all" reasoning again - a
+    // stable, public, front-end-facing contract (a theme's own JS calls
+    // it directly), not part of the versioned /v1 admin/integration
+    // surface, so it lives alongside these other unprefixed routes
+    // rather than inside v1Routes (search.ts's /v1/search/rebuild is the
+    // authenticated write side that does). GET /search.json, not
+    // GET /search: a single reserved path, not a whole prefix, so a
+    // site's own content page can still live at the bare /search URL
+    // (granite-starter's search-demo section does exactly that).
+    app.register(searchPublicRoutes, { config: booted.config });
+    // Conditional, unlike every other registration above - this is what
+    // makes GET /admin genuinely opt-in rather than a reserved
+    // namespace: with no adminBaseUrl configured, the route is never
+    // registered at all, so an unconfigured site can still use "admin"
+    // as an ordinary page path. See routes/admin-redirect.ts's own
+    // comment for the full reasoning.
+    if (serverConfig.adminBaseUrl) {
+        app.register(adminRedirectRoutes, { adminBaseUrl: serverConfig.adminBaseUrl });
+    }
     return app;
 }
 // Neither a recurring timer nor process signal handling exists
@@ -159,6 +181,16 @@ export async function startServer(siteRoot, options = {}) {
         }
         throw error;
     }
+    // The real bound port, not just serverConfig.port verbatim - the
+    // same reasoning tests already rely on (app.server.address()):
+    // port 0 means "OS picks a free one", so echoing the configured
+    // value back would print a meaningless 0 in that case. 127.0.0.1,
+    // not the 0.0.0.0 bind host above - that's what's actually
+    // reachable and clickable from the machine running this.
+    const address = app.server.address();
+    if (address !== null && typeof address !== 'string') {
+        console.log(`Site running at http://127.0.0.1:${address.port}`);
+    }
     if (options.tunnel) {
         try {
             tunnel = await (options.startTunnel ?? startDevTunnel)(serverConfig.port);

package/dist/services/content-read.js

@@ -4,7 +4,6 @@ import { computeEtag } from "./etag.js";
 import { listFilesRecursively } from "./fs-walk.js";
 import { sanitisePath } from "./path-safety.js";
 import { pagePathToUrl } from "./urls.js";
-import { postPathToUrl } from "./post-urls.js";
 export class ContentReadError extends Error {
     reason;
     constructor(reason, message) {
@@ -29,7 +28,7 @@ export function readContentFile(root, relativePath) {
     return { bytes, etag: computeEtag(bytes) };
 }
 // Both contentRoot-relative live paths and draftsRoot-relative draft
-// paths share the identical pages/posts/menus subroot prefix shape
+// paths share the identical pages/menus subroot prefix shape
 // (content/drafts/ mirrors content/'s own layout), so one function
 // handles both with no branching on which root an entry came from.
 // Menus have no public URL - there is no preview route for them.
@@ -37,9 +36,6 @@ function computeContentUrl(relativePath) {
     if (relativePath.startsWith('pages/')) {
         return pagePathToUrl(relativePath.slice('pages/'.length));
     }
-    if (relativePath.startsWith('posts/')) {
-        return postPathToUrl(relativePath.slice('posts/'.length));
-    }
     return null;
 }
 // The later of the live file's and the draft's own mtime, whichever
@@ -87,20 +83,19 @@ function readSummary(fullPath) {
 // anywhere in the build plan - this is the only place a draft-only
 // page (never yet published) is discoverable at all.
 //
-// Deliberately three named walks (pages/posts/menus), not one broad
-// walk of contentRoot: since Group N nested draftsRoot and redirectsPath
+// Deliberately two named walks (pages/menus), not one broad walk of
+// contentRoot: since Group N nested draftsRoot and redirectsPath
 // inside contentRoot (content/drafts/, content/redirects.json), a
 // single broad contentRoot walk would descend into content/drafts/
 // too, double-listing draft files under two different relative-path
 // keys, and would pick up redirects.json as if it were a page. An
 // inclusion-based walk sidesteps both problems structurally, with no
-// exclusion list to maintain. base stays config.contentRoot for all
-// three (not each subroot) so the resulting relative paths ("pages/x.json")
+// exclusion list to maintain. base stays config.contentRoot for both
+// (not each subroot) so the resulting relative paths ("pages/x.json")
 // line up with draftPaths below for the hasDraft/hasLive union logic.
 export function listContent(config, filters) {
     const contentPaths = new Set([
         ...listFilesRecursively(config.pagesRoot, config.contentRoot, '.json'),
-        ...listFilesRecursively(config.postsRoot, config.contentRoot, '.json'),
         ...listFilesRecursively(config.menusRoot, config.contentRoot, '.json'),
     ]);
     const draftPaths = new Set(listFilesRecursively(config.draftsRoot, config.draftsRoot, '.json'));

package/dist/services/delete-content.js

@@ -2,27 +2,16 @@ import { existsSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync }
 import { listFilesRecursively } from "./fs-walk.js";
 import { commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { postPathToUrl } from "./post-urls.js";
 import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirects, serialiseRedirects, } from "./redirects.js";
 import { pagePathToUrl } from "./urls.js";
 import { enqueue } from "./write-queue.js";
 const PAGES_PREFIX = 'pages/';
-const POSTS_PREFIX = 'posts/';
-// Widens the redirect-on-delete gate to posts alongside pages, without
-// touching the has-children subtree check below (PAGES_PREFIX-only,
-// unchanged - posts never have nested children by construction). A
-// tiny duplicated helper, not a shared "collection" abstraction,
-// matching this codebase's existing precedent (e.g. prepareSaveDraft/
-// prepareDiscardDraft mirror rather than share a base with publish.ts/
-// move.ts). Returns null for anything else (menus have no public URL
-// at all, so redirects are meaningless there).
+// Returns null for anything else (menus have no public URL at all, so
+// redirects are meaningless there).
 function urlForDeletedEntry(relativePath) {
     if (relativePath.startsWith(PAGES_PREFIX)) {
         return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
     }
-    if (relativePath.startsWith(POSTS_PREFIX)) {
-        return postPathToUrl(relativePath.slice(POSTS_PREFIX.length));
-    }
     return null;
 }
 export class DeleteContentError extends Error {

package/dist/services/manage-redirects.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { isBlogUrl, urlToPostPath } from "./post-urls.js";
 import { RedirectError, addRedirect, isValidRedirectTarget, loadRedirectsStrict, removeRedirectForPath, serialiseRedirects, } from "./redirects.js";
 import { urlToPagePath } from "./urls.js";
 import { enqueue } from "./write-queue.js";
@@ -13,22 +12,13 @@ export class ManageRedirectError extends Error {
         this.reason = reason;
     }
 }
-// Not required for correctness (resolve-url.ts/resolve-blog-url.ts
-// already guarantee live content always wins over a redirect at the
-// same URL), but rejecting here avoids a marketing manager creating a
-// redirect that would silently never fire.
+// Not required for correctness (resolve-url.ts already guarantees live
+// content always wins over a redirect at the same URL), but rejecting
+// here avoids a marketing manager creating a redirect that would
+// silently never fire.
 function liveContentExistsAt(config, url) {
     const pageFile = sanitisePath(config.pagesRoot, urlToPagePath(url));
-    if (existsSync(pageFile)) {
-        return true;
-    }
-    if (isBlogUrl(url) && existsSync(config.postsRoot)) {
-        const postRelative = urlToPostPath(url);
-        if (postRelative !== null && existsSync(sanitisePath(config.postsRoot, postRelative))) {
-            return true;
-        }
-    }
-    return false;
+    return existsSync(pageFile);
 }
 function validateFromAndTo(from, to) {
     if (!isValidRedirectTarget(from)) {

package/dist/services/migration-runner.js

@@ -1,5 +1,5 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { listFilesRecursively } from "./fs-walk.js";
 import { GitOperationError, commitPaths } from "./git.js";
 import { validateContent } from "./validation.js";
@@ -41,11 +41,23 @@ function applyMigrationChain(content, migrations, currentVersion, path) {
 // Hand-rolled fs snapshot/restore, matching publish.ts's established
 // shape - but simpler: every file the write phase touches already
 // existed with real prior bytes (F3's skip logic guarantees this), so
-// there is no "did this file exist before" branch to carry.
+// there is no "did this file exist before" branch to carry. A
+// relocated file (targetPath !== path) is undone by removing whatever
+// landed at targetPath and restoring the original at its original path.
 function rollback(files) {
     const failures = [];
     for (const file of files) {
         try {
+            if (file.targetPath !== file.path) {
+                try {
+                    unlinkSync(file.targetPath);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT') {
+                        throw error;
+                    }
+                }
+            }
             writeFileSync(file.path, file.originalBytes);
         }
         catch (error) {
@@ -55,27 +67,42 @@ function rollback(files) {
     return failures;
 }
 async function runMigrationsJob(config, themeSchemas, migrations, currentVersion, author) {
-    // Three named walks (pages/posts/menus), not one broad walk of
+    // content/posts/ is a legacy root: posts were folded into pages, and
+    // no code walks a postsRoot for anything else any more (see
+    // config.ts) - it's computed locally, here only, purely to find any
+    // leftover legacy files this migration needs to relocate. A site
+    // that never had posts has no such directory; listFilesRecursively
+    // already returns [] for a missing root, same as every other caller.
+    const legacyPostsRoot = join(config.contentRoot, 'posts');
+    // Named walks (pages/menus/legacy posts), not one broad walk of
     // contentRoot - see content-read.ts's listContent for the identical
     // reasoning (Group N nested draftsRoot/redirectsPath inside
     // contentRoot; a broad walk would double-migrate drafts and try to
     // validate redirects.json as a page). base stays config.contentRoot
-    // for all three so relativePath matches what validateContent expects.
+    // for pages/menus so relativePath matches what validateContent
+    // expects. Legacy posts get their own targetPath: content/posts/
+    // was always flat (no nested slugs), so relocating each file to
+    // content/pages/blog/<slug>.json preserves its old /blog/<slug> URL
+    // as an ordinary nested page - no reserved namespace needed any more.
     const files = [
         ...listFilesRecursively(config.pagesRoot, config.contentRoot, '.json').map((rel) => ({
             path: join(config.contentRoot, rel),
-            relativePath: rel,
-        })),
-        ...listFilesRecursively(config.postsRoot, config.contentRoot, '.json').map((rel) => ({
-            path: join(config.contentRoot, rel),
+            targetPath: join(config.contentRoot, rel),
             relativePath: rel,
         })),
         ...listFilesRecursively(config.menusRoot, config.contentRoot, '.json').map((rel) => ({
             path: join(config.contentRoot, rel),
+            targetPath: join(config.contentRoot, rel),
             relativePath: rel,
         })),
+        ...listFilesRecursively(legacyPostsRoot, legacyPostsRoot, '.json').map((rel) => ({
+            path: join(legacyPostsRoot, rel),
+            targetPath: join(config.contentRoot, 'pages', 'blog', rel),
+            relativePath: join('pages', 'blog', rel),
+        })),
         ...listFilesRecursively(config.draftsRoot, config.draftsRoot, '.json').map((rel) => ({
             path: join(config.draftsRoot, rel),
+            targetPath: join(config.draftsRoot, rel),
             relativePath: rel,
         })),
     ];
@@ -84,10 +111,14 @@ async function runMigrationsJob(config, themeSchemas, migrations, currentVersion
     // files so far is simply discarded - a mid-list failure aborts with
     // literally zero writes having happened (F4's primary scenario).
     const toMigrate = [];
-    for (const { path, relativePath } of files) {
+    for (const { path, targetPath, relativePath } of files) {
         const originalBytes = readFileSync(path);
         const parsed = JSON.parse(originalBytes.toString('utf-8'));
         const schemaVersion = parsed.schemaVersion;
+        // A legacy posts/ file can never already be at currentVersion: the
+        // posts/ directory only ever held content written before this very
+        // migration existed, so this skip and the relocation above never
+        // conflict in practice.
         if (typeof schemaVersion === 'number' && schemaVersion >= currentVersion) {
             continue;
         }
@@ -97,16 +128,27 @@ async function runMigrationsJob(config, themeSchemas, migrations, currentVersion
             throw new MigrationError('validation-failed', `Migrated content at "${path}" failed validation: ${JSON.stringify(result.errors)}`);
         }
         const migratedBytes = Buffer.from(JSON.stringify(migrated, null, 2));
-        toMigrate.push({ path, originalBytes, migratedBytes });
+        toMigrate.push({ path, targetPath, originalBytes, migratedBytes });
     }
     if (toMigrate.length === 0) {
         return;
     }
     try {
         for (const file of toMigrate) {
-            writeFileSync(file.path, file.migratedBytes);
+            if (file.targetPath !== file.path) {
+                mkdirSync(dirname(file.targetPath), { recursive: true });
+            }
+            writeFileSync(file.targetPath, file.migratedBytes);
+            if (file.targetPath !== file.path) {
+                unlinkSync(file.path);
+            }
+        }
+        const committedPaths = new Set();
+        for (const file of toMigrate) {
+            committedPaths.add(file.path);
+            committedPaths.add(file.targetPath);
         }
-        commitPaths(config.siteRoot, toMigrate.map((file) => file.path), `chore: migrate content to schema version ${currentVersion}`, author);
+        commitPaths(config.siteRoot, [...committedPaths], `chore: migrate content to schema version ${currentVersion}`, author);
     }
     catch (error) {
         const failures = rollback(toMigrate);

package/dist/services/publish.js

@@ -2,24 +2,18 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import { dirname } from 'node:path';
 import { GitOperationError, commitPaths } from "./git.js";
 import { sanitisePath } from "./path-safety.js";
-import { postPathToUrl } from "./post-urls.js";
 import { loadRedirects, removeRedirectForPath, serialiseRedirects } from "./redirects.js";
 import { pagePathToUrl } from "./urls.js";
 import { validateContent } from "./validation.js";
 import { enqueue } from "./write-queue.js";
 const PAGES_PREFIX = 'pages/';
-const POSTS_PREFIX = 'posts/';
 // Mirrors delete-content.ts's urlForDeletedEntry - a tiny duplicated
-// helper, not a shared abstraction. Widens the stale-redirect-clearing
-// block below to posts alongside pages; returns null for anything
-// else (menus have no public URL, so redirect semantics don't apply).
+// helper, not a shared abstraction. Returns null for anything else
+// (menus have no public URL, so redirect semantics don't apply).
 function urlForPublishedEntry(relativePath) {
     if (relativePath.startsWith(PAGES_PREFIX)) {
         return pagePathToUrl(relativePath.slice(PAGES_PREFIX.length));
     }
-    if (relativePath.startsWith(POSTS_PREFIX)) {
-        return postPathToUrl(relativePath.slice(POSTS_PREFIX.length));
-    }
     return null;
 }
 export class PublishError extends Error {
@@ -150,12 +144,12 @@ export function preparePublishDrafts(config, themeSchemas, relativePaths) {
             writeFileSync(entry.livePath, entry.draftContent);
             unlinkSync(entry.draftPath);
         }
-        // E5 (publish half): a brand-new live page or post may supersede a
-        // stale redirect recorded at its own URL (checklist wording:
-        // "creating a page at a path that has a redirect entry"). Only
-        // applies to pages/posts content - redirect semantics aren't
-        // defined for menus (no public URL), so anything else is skipped
-        // silently via urlForPublishedEntry's null return.
+        // E5 (publish half): a brand-new live page may supersede a stale
+        // redirect recorded at its own URL (checklist wording: "creating a
+        // page at a path that has a redirect entry"). Only applies to page
+        // content - redirect semantics aren't defined for menus (no public
+        // URL), so anything else is skipped silently via
+        // urlForPublishedEntry's null return.
         const qualifyingUrls = entries
             .map((entry) => urlForPublishedEntry(entry.relativePath))
             .filter((url) => url !== null);

package/dist/services/rate-limit-config.d.ts

@@ -1,7 +1,7 @@
 export declare const WRITE_ROUTE_RATE_LIMIT: {
     rateLimit: {};
 };
-export declare const CAPABILITIES_RATE_LIMIT: {
+export declare const NO_AUTH_ROUTE_RATE_LIMIT: {
     rateLimit: {
         max: number;
         timeWindow: number;

package/dist/services/rate-limit-config.js

@@ -14,7 +14,9 @@
 // route's own config.rateLimit only needs *something* present to opt
 // in, not a duplicated copy of the numbers.
 export const WRITE_ROUTE_RATE_LIMIT = { rateLimit: {} };
-// Generous defense-in-depth against basic scanning of the one endpoint
-// reachable with zero credentials, not a meaningful throttle on
-// legitimate use.
-export const CAPABILITIES_RATE_LIMIT = { rateLimit: { max: 300, timeWindow: 60000 } };
+// Generous defense-in-depth against basic scanning/abuse of the
+// endpoints reachable with zero credentials (GET /v1/capabilities,
+// GET /v1/search), not a meaningful throttle on legitimate use - a
+// real front-end calling search on every keystroke of a live search
+// box should never realistically hit this.
+export const NO_AUTH_ROUTE_RATE_LIMIT = { rateLimit: { max: 300, timeWindow: 60000 } };

package/dist/services/validation.d.ts

@@ -18,7 +18,6 @@ export interface ThemeSchemas {
 export declare function requiredFieldsHaveValidDefaults(schema: object): boolean;
 export declare function validateInstance(instance: unknown, kind: 'section' | 'block', themeSchemas: ThemeSchemas): ValidationResult;
 export declare function validatePage(page: unknown, themeSchemas: ThemeSchemas): ValidationResult;
-export declare function validatePost(post: unknown, themeSchemas: ThemeSchemas): ValidationResult;
 export declare function validateMenu(menu: unknown): ValidationResult;
 export declare function validateRedirects(redirects: unknown): ValidationResult;
 export declare function validateContent(relativePath: string, content: unknown, themeSchemas: ThemeSchemas): ValidationResult;

package/dist/services/validation.js

@@ -12,7 +12,6 @@ function readSchema(filename) {
 const instanceSchema = readSchema('instance.schema.json');
 ajv.addSchema(instanceSchema);
 const validatePageEnvelope = ajv.compile(readSchema('page.schema.json'));
-const validatePostEnvelope = ajv.compile(readSchema('post.schema.json'));
 const validateMenuEnvelope = ajv.compile(readSchema('menu.schema.json'));
 const validateRedirectsEnvelope = ajv.compile(readSchema('redirects.schema.json'));
 const validateInstanceEnvelope = ajv.compile(instanceSchema);
@@ -112,10 +111,6 @@ export function validateInstance(instance, kind, themeSchemas) {
     }
     return { valid: errors.length === 0, errors };
 }
-// Shared by validatePage and validatePost: both envelopes require an
-// identical sections/blocks recursion once their own envelope-level
-// shape is confirmed valid - genuinely load-bearing for two real
-// content types now, not a speculative abstraction.
 function validateSectionedContent(envelopeValidate, content, themeSchemas) {
     const envelopeResult = runValidator(envelopeValidate, content);
     if (!envelopeResult.valid) {
@@ -132,9 +127,6 @@ function validateSectionedContent(envelopeValidate, content, themeSchemas) {
 export function validatePage(page, themeSchemas) {
     return validateSectionedContent(validatePageEnvelope, page, themeSchemas);
 }
-export function validatePost(post, themeSchemas) {
-    return validateSectionedContent(validatePostEnvelope, post, themeSchemas);
-}
 export function validateMenu(menu) {
     return runValidator(validateMenuEnvelope, menu);
 }
@@ -151,8 +143,5 @@ export function validateContent(relativePath, content, themeSchemas) {
     if (relativePath.startsWith('menus/')) {
         return validateMenu(content);
     }
-    if (relativePath.startsWith('posts/')) {
-        return validatePost(content, themeSchemas);
-    }
     return validatePage(content, themeSchemas);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-a/cms-agent",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -29,7 +29,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.6.0"
+    "node": ">=22.16.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit -p tsconfig.json",

package/dist/schemas/post.schema.json

@@ -1,25 +0,0 @@
-{
-  "$id": "post.schema.json",
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Post",
-  "type": "object",
-  "additionalProperties": false,
-  "required": ["schemaVersion", "title", "type", "layout", "published", "author", "publishDate", "tags", "sections"],
-  "properties": {
-    "schemaVersion": { "type": "integer", "minimum": 1 },
-    "title": { "type": "string", "minLength": 1 },
-    "type": { "const": "post" },
-    "layout": { "type": "string", "minLength": 1 },
-    "published": { "type": "boolean" },
-    "author": { "type": "string", "minLength": 1 },
-    "publishDate": { "type": "string", "minLength": 1 },
-    "tags": {
-      "type": "array",
-      "items": { "type": "string", "minLength": 1 }
-    },
-    "sections": {
-      "type": "array",
-      "items": { "$ref": "instance.schema.json" }
-    }
-  }
-}