domma-cms 0.89.0 → 0.90.0

package/server/services/permissionRegistry.js

@@ -226,6 +226,17 @@ export const REGISTRY = [
             {key: 'delete', label: 'Reset', description: 'Reset all counters'}
         ]
     },
+    {
+        key: 'seo',
+        label: 'SEO',
+        description: 'How the site looks to search engines: the audit, page titles and descriptions, redirects, the sitemap and robots.txt.',
+        icon: 'search',
+        group: 'Tools',
+        actions: [
+            {key: 'read', label: 'View', description: 'See the audit, redirects and sitemap; run the audit'},
+            {key: 'manage', label: 'Manage', description: 'Change page titles and descriptions, redirects and settings'}
+        ]
+    },
     {
         key: 'notes',
         label: 'Notes',

package/server/services/plugins.js

@@ -165,7 +165,7 @@ export function isCorePlugin(name) { return CORE_PLUGINS.has(name); }
  * same data - and, like supersession, nothing is written down: a lapsed
  * licence means the plugin does not load and the core Tool is simply back.
  */
-export const BUILT_IN_TOOLS = new Set(['notes', 'todo', 'analytics', 'contacts']);
+export const BUILT_IN_TOOLS = new Set(['notes', 'todo', 'analytics', 'contacts', 'seo']);
 
 /** Built-in Tool → {plugin, route}, for the plugins that loaded this boot. */
 const _toolTakeovers = {};
@@ -196,6 +196,16 @@ export function toolTakeoversOf(manifest, taken = {}) {
     return out;
 }
 
+/**
+ * Plugins that became part of the CMS. A site updated from an engine that
+ * shipped one still has its folder; it is never loaded again (it would run
+ * beside the built-in copy - two redirect guards, two sets of tags) and its
+ * data is carried over by the built-in feature.
+ */
+export const RETIRED_PLUGINS = Object.freeze({
+    seo: 'Built in since 0.90.0 (server/services/seo) - its data moves to content/seo and config/seo.json.'
+});
+
 /**
  * Scan the plugins/ directory and return all valid manifests.
  * Validates mandatory fields and required files (plugin.js, config.js).
@@ -212,7 +222,7 @@ export async function discoverPlugins() {
     }
 
     const plugins = [];
-    for (const entry of entries.filter(e => e.isDirectory() && !e.name.startsWith('_'))) {
+    for (const entry of entries.filter(e => e.isDirectory() && !e.name.startsWith('_') && !RETIRED_PLUGINS[e.name])) {
         const dir = entry.name;
         const pluginDir = path.join(PLUGINS_DIR, dir);
         const manifestPath = path.join(pluginDir, 'plugin.json');

package/{plugins/seo/server → server/services/seo}/audit.js

@@ -2,12 +2,12 @@
  * SEO - the audit: every URL in the sitemap (and every published page hidden
  * from search engines), fetched INSIDE the process with fastify.inject - no
  * network, no certificate, the same HTML a visitor gets - and judged by
- * admin/lib/analyse.js.
+ * admin/js/lib/seo-analyse.js.
  *
  * The requests carry `user-agent: DommaSEO/1 (audit)` and `x-domma-seo: audit`
  * so analytics and SEO Pro's 404 log can leave them out.
  */
-import {analyse, scanHtml} from '../admin/lib/analyse.js';
+import {analyse, scanHtml} from '../../../admin/js/lib/seo-analyse.js';
 
 export const AUDIT_UA = 'DommaSEO/1 (audit)';
 const CONCURRENCY = 3;

package/server/services/seo/index.js

@@ -0,0 +1,345 @@
+/**
+ * SEO - built in since 0.90.0 (it was the free `seo` plugin in 0.89.0).
+ *
+ *  - Redirects: a global onRequest guard (GET/HEAD, never /api or /admin);
+ *    rules in content/seo/redirects.json (admin/js/lib/seo-redirects.js).
+ *    A renamed page gets one (content:pageRenamed), older rules re-aimed.
+ *  - What search engines are given: the 'seo:meta', 'sitemap:entries' and
+ *    'robots:lines' transforms (hooks.js section 8) - a URL's overrides,
+ *    Organization / BlogPosting JSON-LD, sitemap exclusions, robots rules.
+ *  - The audit (./audit.js): every sitemap URL fetched in-process and judged.
+ *  - The registry (./registry.js) SEO Pro plugs into.
+ *
+ * A switchable built-in Tool (services/tools.js): when it is off, none of the
+ * above runs and /api/seo answers 404. The switch restarts the site, so the
+ * boot-time state is the state.
+ *
+ * `seoEngine()` is the one instance; routes/api/seo.js is its API.
+ *
+ * @module services/seo
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import fp from 'fastify-plugin';
+import {createStore} from './store.js';
+import {auditAll, auditOne, AUDIT_UA, fetchLocal, hostOf} from './audit.js';
+import {seoRegistry} from './registry.js';
+import {analyse, scanHtml, siteIssues} from '../../../admin/js/lib/seo-analyse.js';
+import {chains, checkRule, matchRedirect, MAX_RULES, normalisePath, onMoved} from '../../../admin/js/lib/seo-redirects.js';
+import {applySeo, robotsLines} from '../../../admin/js/lib/seo-schema.js';
+import {checkSettings, excluded, mergeDefaults} from '../../../admin/js/lib/seo-settings.js';
+import {getConfig, saveConfig} from '../../config.js';
+import {hooks as coreHooks, getSitemapSources, registerTransform} from '../hooks.js';
+import {listPages} from '../content.js';
+import {invalidateTags} from '../cache/index.js';
+
+const SKIP = /^\/(api|admin)(\/|$)/;
+
+let engine = null;
+
+/** The SEO engine, once `seoPlugin` has registered it (null before). */
+export const seoEngine = () => engine;
+
+/** Settings: config/seo.json over the defaults. */
+function readSettings() {
+    try { return mergeDefaults(getConfig('seo')); } catch { return mergeDefaults({}); }
+}
+
+/**
+ * The SEO plugin's data, once, when SEO became built in (0.89.0 -> 0.90.0):
+ * its settings from config/plugins.json, redirects (with their counters) and
+ * overrides from plugins/seo/data. Never over anything already here.
+ */
+export function migrateFromPlugin({root = process.cwd(), log = console} = {}) {
+    const moved = [];
+    const cfgFile = path.join(root, 'config', 'seo.json');
+    const pluginData = path.join(root, 'plugins', 'seo', 'data');
+    const dir = path.join(root, 'content', 'seo');
+    try {
+        if (!fs.existsSync(cfgFile)) {
+            const plugins = JSON.parse(fs.readFileSync(path.join(root, 'config', 'plugins.json'), 'utf8'));
+            const s = plugins?.seo?.settings;
+            if (s && typeof s === 'object' && Object.keys(s).length) {
+                fs.writeFileSync(cfgFile, JSON.stringify(mergeDefaults(s), null, 2) + '\n');
+                moved.push('settings');
+            }
+        }
+    } catch { /* no plugins.json, or no SEO settings in it */ }
+    const readJson = (f) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return null; } };
+    const old = readJson(path.join(pluginData, 'redirects.json'));
+    if (Array.isArray(old?.rules) && old.rules.length && !fs.existsSync(path.join(dir, 'redirects.json'))) {
+        fs.mkdirSync(dir, {recursive: true});
+        const rules = old.rules.map(({hits: _h, lastHit: _l, ...r}) => r);
+        const hits = Object.fromEntries(old.rules.filter(r => r.hits).map(r => [r.id, {hits: r.hits, lastHit: r.lastHit || null}]));
+        fs.writeFileSync(path.join(dir, 'redirects.json'), JSON.stringify({rules}, null, 2) + '\n');
+        if (Object.keys(hits).length) fs.writeFileSync(path.join(dir, 'hits.json'), JSON.stringify(hits) + '\n');
+        moved.push(`${rules.length} redirect(s)`);
+    }
+    const over = readJson(path.join(pluginData, 'overrides.json'));
+    if (over && typeof over === 'object' && Object.keys(over).length && !fs.existsSync(path.join(dir, 'overrides.json'))) {
+        fs.mkdirSync(dir, {recursive: true});
+        fs.writeFileSync(path.join(dir, 'overrides.json'), JSON.stringify(over, null, 2) + '\n');
+        moved.push(`${Object.keys(over).length} override(s)`);
+    }
+    if (moved.length) log.info?.(`[seo] carried over from the SEO plugin: ${moved.join(', ')}.`);
+    return moved;
+}
+
+async function seo(fastify, {enabled = true, getBaseUrl = null, rolesService = null} = {}) {
+    const log = fastify.log;
+    const registry = seoRegistry();
+    if (!enabled) {
+        log.info('[seo] SEO is switched off on this site.');
+        return;
+    }
+    try { migrateFromPlugin({log}); } catch (err) { log.warn(`[seo] the SEO plugin's data was not carried over: ${err.message}`); }
+    // Admins may use it, once - removed by hand, it stays removed (roles.js grantPermissionOnce).
+    rolesService?.grantPermissionOnce?.('admin', 'seo', 'core')?.catch?.(() => {});
+
+    let cfg = readSettings();
+    const store = createStore();
+    const site = () => { try { return getConfig('site') || {}; } catch { return {}; } };
+    const originOf = (request) => {
+        try { return String(getBaseUrl?.(request) || site().baseUrl || '').replace(/\/+$/, ''); } catch { return ''; }
+    };
+    const sitemapChanged = () => { invalidateTags(['sitemap']).catch(() => {}); };
+
+    // ---- 1. Redirects, ahead of everything else ----
+    fastify.addHook('onRequest', async (request, reply) => {
+        try {
+            if (request.method !== 'GET' && request.method !== 'HEAD') return;
+            const url = String(request.url || '');
+            if (SKIP.test(url)) return;
+            const rules = store.rules();
+            if (!rules.length) return;
+            const hit = matchRedirect(rules, url);
+            if (!hit) return;
+            if (request.headers['x-domma-seo'] !== 'audit') store.countHit(hit.rule.id);
+            if (hit.code === 410) {
+                reply.code(410).header('content-type', 'text/plain; charset=utf-8').send('Gone');
+                return reply;
+            }
+            reply.code(hit.code).header('location', hit.location)
+                .header('cache-control', hit.code === 301 || hit.code === 308 ? 'public, max-age=3600' : 'no-store').send();
+            return reply;
+        } catch (err) {
+            log.warn(`[seo] redirect skipped: ${err.message}`);
+        }
+    });
+    const saveHits = setInterval(() => store.saveHits(), 60_000);
+    saveHits.unref?.();
+
+    const onRenamed = ({from, to} = {}) => {
+        if (!cfg.redirects.onRename || !from || !to) return;
+        try {
+            store.setRules(onMoved(store.rulesWithHits(), from, to, {id: newId()}));
+            log.info(`[seo] ${from} moved to ${to}: redirect added.`);
+        } catch (err) {
+            log.warn(`[seo] no redirect for the move of ${from}: ${err.message}`);
+        }
+    };
+    coreHooks.on('content:pageRenamed', onRenamed);
+
+    // ---- 2. What search engines are given ----
+    registerTransform('seo:meta', (meta, ctx) => {
+        try {
+            const origin = String(ctx?.baseUrl || '').replace(/\/+$/, '');
+            return applySeo(meta, {page: ctx?.page, kind: ctx?.kind, origin, siteTitle: ctx?.site?.title || '', settings: cfg,
+                override: store.override(normalisePath(ctx?.page?.urlPath || '/') || '/')});
+        } catch (err) {
+            log.warn(`[seo] page tags left as they were: ${err.message}`);
+            return meta;
+        }
+    });
+    registerTransform('sitemap:entries', (entries) => {
+        const rules = store.rules();
+        const over = store.overrides();
+        return entries.filter(e => !excluded(e.urlPath, cfg.sitemap.exclude)
+            && cfg.sitemap.sources[e.source] !== false
+            && over[normalisePath(e.urlPath)]?.noindex !== true
+            && !(rules.length && matchRedirect(rules, e.urlPath)));
+    });
+    registerTransform('robots:lines', (lines, ctx) => robotsLines(lines, cfg.robots, ctx?.sitemapUrl));
+
+    // ---- 3. The audit ----
+    const sitemap = await import('../sitemap.js');
+    let running = null;
+    let progress = {done: 0, total: 0};
+    const isPublic = (p) => p.status === 'published' && (p.visibility || 'public') === 'public' && p.urlPath !== '/404';
+
+    /** What to audit: the sitemap, plus published pages kept out of it (so they show as hidden). */
+    async function auditList(origin) {
+        const list = [];
+        const seen = new Set();
+        for (const e of await sitemap.listSitemapEntries(origin, {log})) {
+            seen.add(e.urlPath);
+            list.push({urlPath: e.urlPath, source: e.source, title: e.title});
+        }
+        for (const p of await listPages()) {
+            if (seen.has(p.urlPath) || !isPublic(p)) continue;
+            list.push({urlPath: p.urlPath, source: 'pages', title: p.title, noindex: p.seo?.noindex === true, unlisted: true});
+        }
+        return list;
+    }
+    async function focusMap() {
+        const map = {};
+        for (const p of await listPages()) if (p.seo?.focus) map[p.urlPath] = p.seo.focus;
+        for (const [p, o] of Object.entries(store.overrides())) if (o.focus) map[p] = o.focus;
+        return map;
+    }
+    async function runAudit(origin) {
+        if (running) return running;
+        running = (async () => {
+            const started = Date.now();
+            try {
+                const o = origin || store.audit().origin || String(site().baseUrl || '').replace(/\/+$/, '');
+                const [list, focus] = await Promise.all([auditList(o), focusMap()]);
+                progress = {done: 0, total: list.length};
+                const results = await auditAll(fastify, list, {origin: o, focusOf: (p) => focus[p] || '', limits: cfg.audit,
+                    onProgress: (done, total) => { progress = {done, total}; }});
+                store.setAudit({at: new Date().toISOString(), ms: Date.now() - started, origin: o, results});
+                registry.emit('audit', store.audit());
+                return store.audit();
+            } catch (err) {
+                log.warn(`[seo] audit failed: ${err.message}`);
+                return store.audit();
+            } finally {
+                running = null;
+            }
+        })();
+        return running;
+    }
+    function summary(a = store.audit()) {
+        const rows = a.results || [];
+        const judged = rows.filter(r => typeof r.score === 'number' && !r.noindex);
+        const issues = siteIssues(rows);
+        return {
+            at: a.at, ms: a.ms || 0, origin: a.origin || '', running: Boolean(running), progress,
+            pages: rows.length,
+            score: judged.length ? Math.round(judged.reduce((n, r) => n + r.score, 0) / judged.length) : null,
+            failing: rows.filter(r => r.error || r.failing > 0).length,
+            broken: rows.filter(r => r.error).length,
+            hidden: rows.filter(r => r.noindex).length,
+            duplicates: issues.duplicateTitles.length + issues.duplicateDescriptions.length,
+            issues
+        };
+    }
+    /** Audit one URL again (after its fields changed), in place. */
+    async function reaudit(urlPath, {origin, focus}) {
+        const a = store.audit();
+        const at = (a.results || []).findIndex(r => r.urlPath === urlPath);
+        if (at < 0) return;
+        const row = await auditOne(fastify, a.results[at], {origin: a.origin || origin, focus, limits: cfg.audit});
+        const results = [...a.results];
+        results[at] = row;
+        store.setAudit({...a, results});
+    }
+
+    // ---- 4. Redirect rules ----
+    function addRule(input) {
+        const rules = store.rules();
+        if (rules.length >= MAX_RULES) return {errors: {from: `There are ${MAX_RULES} redirects already.`}};
+        const {errors, rule} = checkRule(input, rules);
+        if (Object.keys(errors).length) return {errors};
+        const full = {id: newId(), ...rule, at: new Date().toISOString()};
+        store.setRules([...rules, full]);
+        sitemapChanged();
+        return {rule: {...full, hits: 0, lastHit: null}};
+    }
+    function updateRule(id, input) {
+        const rules = store.rules();
+        const old = rules.find(r => r.id === id);
+        if (!old) return {missing: true};
+        const {errors, rule} = checkRule({...old, ...input, auto: false}, rules.filter(r => r !== old));
+        if (Object.keys(errors).length) return {errors};
+        const next = {...old, ...rule};
+        delete next.auto;
+        store.setRules(rules.map(r => (r === old ? next : r)));
+        sitemapChanged();
+        return {rule: next};
+    }
+    function removeRules(ids) {
+        const drop = new Set(ids);
+        store.setRules(store.rules().filter(r => !drop.has(r.id)));
+        sitemapChanged();
+    }
+
+    /** The sitemap entries before SEO's filter (pages + every source), to show what it leaves out. */
+    async function rawEntries(origin) {
+        const out = (await listPages()).filter(p => isPublic(p) && !p.seo?.noindex).map(p => ({urlPath: p.urlPath, title: p.title, source: 'pages'}));
+        const seen = new Set(out.map(p => p.urlPath));
+        for (const s of getSitemapSources()) {
+            try {
+                for (const e of (await s.list({baseUrl: origin})) || []) {
+                    if (!e?.urlPath || seen.has(e.urlPath)) continue;
+                    seen.add(e.urlPath);
+                    out.push({urlPath: e.urlPath, title: e.title || '', source: s.id});
+                }
+            } catch { /* shown as nothing from that source */ }
+        }
+        return out;
+    }
+
+    function saveSettings(input) {
+        const {errors, settings} = checkSettings(input, cfg);
+        if (Object.keys(errors).length) return {errors};
+        saveConfig('seo', settings);
+        cfg = settings;
+        sitemapChanged();
+        schedule();
+        return {settings};
+    }
+
+    // ---- 5. The registry SEO Pro plugs into ----
+    Object.assign(registry.services, {
+        version: 1,
+        builtIn: true,
+        settings: () => cfg,
+        listEntries: (origin) => sitemap.listSitemapEntries(origin, {log}),
+        auditList,
+        fetchPage: (urlPath, origin) => fetchLocal(fastify, urlPath, hostOf(origin)),
+        scanHtml, analyse,
+        audit: {latest: () => store.audit(), summary: () => summary(), run: (origin) => runAudit(origin)},
+        redirects: {list: () => store.rulesWithHits(), match: (p) => matchRedirect(store.rules(), p), add: (input) => addRule(input)},
+        auditUserAgent: AUDIT_UA
+    });
+
+    // ---- 6. On a schedule ----
+    let timer = null;
+    function schedule() {
+        if (timer) clearInterval(timer);
+        timer = null;
+        if (!cfg.audit.everyHours) return;
+        timer = setInterval(() => { runAudit().catch(() => {}); }, cfg.audit.everyHours * 3_600_000);
+        timer.unref?.();
+    }
+    schedule();
+    // The first audit a few minutes after start, if the last is older than the interval.
+    const first = setTimeout(() => {
+        const at = Date.parse(store.audit().at || 0) || 0;
+        if (cfg.audit.everyHours && Date.now() - at > cfg.audit.everyHours * 3_600_000) runAudit().catch(() => {});
+    }, 3 * 60_000);
+    first.unref?.();
+
+    fastify.addHook('onClose', (_i, done) => {
+        clearInterval(timer); clearInterval(saveHits); clearTimeout(first);
+        coreHooks.off?.('content:pageRenamed', onRenamed);
+        store.close();
+        done();
+    });
+
+    engine = {
+        store, registry, originOf, summary, runAudit, reaudit, auditList, rawEntries,
+        addRule, updateRule, removeRules, saveSettings, sitemapChanged,
+        settings: () => cfg, chains, matchRedirect, normalisePath, scanHtml, analyse,
+        fetchLocal: (urlPath, origin) => fetchLocal(fastify, urlPath, hostOf(origin)),
+        isRunning: () => Boolean(running), maxRules: MAX_RULES
+    };
+}
+
+function newId() {
+    return `r${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+
+/** Global (fastify-plugin): the redirect guard must see every request. */
+export const seoPlugin = fp(seo, {name: 'core-seo'});

package/{plugins/seo/server → server/services/seo}/registry.js

@@ -1,9 +1,10 @@
 /**
- * SEO's door for extensions - how SEO Pro adds to the free SEO without
- * replacing it (the Shopping Cart's pattern, lib/extensions.js there).
+ * SEO's door for extensions - how SEO Pro adds to the built-in SEO without
+ * replacing it (the Shopping Cart's pattern). The same registry the SEO plugin
+ * had before SEO was built in (0.90.0), so SEO Pro works with either.
  *
  * It lives on `globalThis` under a registered symbol, so an extension reaches
- * it WITHOUT importing a file from this plugin. An extension registers from its
+ * it WITHOUT importing a core file. An extension registers from its
  * `onReady` hook, when every plugin has loaded:
  *
  *   const seo = globalThis[Symbol.for('domma.seo')];
@@ -16,6 +17,7 @@
  * and reads through `seo.services` (listEntries, auditList, fetchPage,
  * scanHtml, analyse, audit {latest, summary, run}, redirects {list, match, add}).
  * A lapsed licence means the extension never loads and SEO carries on alone.
+ * A tab's `module` is a `/plugins/<slug>/...` URL exporting mount(root, ctx).
  */
 export const KEY = Symbol.for('domma.seo');
 export const VERSION = 1;

package/server/services/seo/store.js

@@ -0,0 +1,110 @@
+/**
+ * SEO - its data. Held in memory (the redirect guard and the 'seo:meta'
+ * transform run on every request and must not touch the disk) and written back
+ * a moment after each change; a file changed on disk (a restore, a pull of the
+ * site's repo) is read again within a few seconds.
+ *
+ * In content/seo/ - authored, so tracked by the site's repo:
+ *   redirects.json  {rules: [{id, from, to, code, note, auto, at}]}   see admin/js/lib/seo-redirects.js
+ *   overrides.json  {"/path": {title, description, image, noindex, focus}}
+ * Runtime state, kept out of the repo (services/siteGitignore.js):
+ *   hits.json       {ruleId: {hits, lastHit}} - kept apart so a visit never dirties redirects.json
+ *   audit.json      {at, origin, results: [...]}
+ *
+ * @module services/seo/store
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** Where SEO keeps its files - resolved per call, as analyticsDir() is. */
+export const seoDir = () => path.resolve('content', 'seo');
+
+function jsonFile(file, empty, {pretty = true} = {}) {
+    let value = read();
+    let mtime = stat();
+    let timer = null;
+    let checked = Date.now();
+
+    function stat() { try { return fs.statSync(file).mtimeMs; } catch { return 0; } }
+    function read() {
+        try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return structuredClone(empty); }
+    }
+    function flush() {
+        timer = null;
+        try {
+            fs.mkdirSync(path.dirname(file), {recursive: true});
+            fs.writeFileSync(`${file}.tmp`, JSON.stringify(value, null, pretty ? 2 : 0) + '\n');
+            fs.renameSync(`${file}.tmp`, file);
+            mtime = stat();
+        } catch { /* tried again with the next change */ }
+    }
+    return {
+        get() {
+            const now = Date.now();
+            if (!timer && now - checked > 3000) {
+                checked = now;
+                const m = stat();
+                if (m && m !== mtime) { value = read(); mtime = m; }
+            }
+            return value;
+        },
+        set(next, {soon = 500} = {}) {
+            value = next;
+            if (timer) clearTimeout(timer);
+            timer = setTimeout(flush, soon);
+            timer.unref?.();
+            return value;
+        },
+        flush() { if (timer) { clearTimeout(timer); flush(); } }
+    };
+}
+
+/**
+ * @param {string} [dir] - defaults to content/seo
+ */
+export function createStore(dir = seoDir()) {
+    const redirects = jsonFile(path.join(dir, 'redirects.json'), {rules: []});
+    const hits = jsonFile(path.join(dir, 'hits.json'), {}, {pretty: false});
+    const overrides = jsonFile(path.join(dir, 'overrides.json'), {});
+    const audit = jsonFile(path.join(dir, 'audit.json'), {at: null, origin: '', results: []}, {pretty: false});
+    const rulesNow = () => (Array.isArray(redirects.get()?.rules) ? redirects.get().rules : []);
+    let hitsDirty = false;
+    return {
+        /** The rules as stored (no counters) - what matching uses. */
+        rules: rulesNow,
+        /** The rules with their counters, for the screen and SEO Pro. */
+        rulesWithHits() {
+            const h = hits.get() || {};
+            return rulesNow().map(r => ({...r, hits: h[r.id]?.hits || 0, lastHit: h[r.id]?.lastHit || null}));
+        },
+        setRules(rules) {
+            const clean = rules.map(({hits: _h, lastHit: _l, ...r}) => r);
+            redirects.set({rules: clean});
+            const ids = new Set(clean.map(r => r.id));
+            const h = hits.get() || {};
+            if (Object.keys(h).some(id => !ids.has(id))) hits.set(Object.fromEntries(Object.entries(h).filter(([id]) => ids.has(id))));
+        },
+        /** One use of a rule - in memory; saved by saveHits() once a minute. */
+        countHit(id) {
+            const h = hits.get() || {};
+            const e = h[id] ||= {hits: 0, lastHit: null};
+            e.hits++;
+            e.lastHit = new Date().toISOString();
+            hitsDirty = true;
+        },
+        saveHits() { if (hitsDirty) { hitsDirty = false; hits.set(hits.get(), {soon: 0}); } },
+        overrides: () => overrides.get() || {},
+        override: (urlPath) => overrides.get()?.[urlPath] || null,
+        setOverride(urlPath, fields) {
+            const all = {...overrides.get()};
+            const clean = Object.fromEntries(Object.entries(fields || {}).filter(([, v]) => v !== '' && v !== null && v !== undefined && v !== false));
+            if (Object.keys(clean).length) all[urlPath] = clean;
+            else delete all[urlPath];
+            overrides.set(all);
+            return all[urlPath] || null;
+        },
+        audit: () => audit.get(),
+        setAudit: (a) => audit.set(a, {soon: 100}),
+        close() { this.saveHits(); redirects.flush(); hits.flush(); overrides.flush(); audit.flush(); }
+    };
+}

package/server/services/siteGitignore.js

@@ -49,7 +49,7 @@ const SITE_ROOTS = ['content', 'config', 'plugins'];
  */
 export const RETIRED_PLUGINS = [
     'analytics', 'contacts', 'notes', 'todo', 'demo-viewer', 'theme-switcher', 'site-search',
-    'seo-pro', 'shopping-cart', 'form-builder'
+    'seo', 'seo-pro', 'shopping-cart', 'form-builder'
 ];
 
 /**
@@ -309,6 +309,9 @@ export function buildGitignore({sitePlugins = [], pluginContent = {}, sitePublic
         '/content/sessions/',
         '/content/versions/',
         '/content/analytics/',
+        // SEO's runtime state; its redirects and overrides beside them are authored, and tracked.
+        '/content/seo/audit.json',
+        '/content/seo/hits.json',
         '/content/instances_log.json',
         '/content/preview-links.json',
         '/config/connections.json*',

package/server/services/tools.js

@@ -46,7 +46,8 @@ export const CORE_TOOLS = Object.freeze([
     {name: 'contacts', displayName: 'Contacts', icon: 'users', description: 'An address book for each user, with groups.'},
     {name: 'notes', displayName: 'Notes', icon: 'edit-3', description: 'Private notes for each user.'},
     {name: 'todo', displayName: 'Todo', icon: 'check-square', description: 'To-do lists with due dates and reminders.'},
-    {name: 'analytics', displayName: 'Analytics', icon: 'chart-bar', description: 'Page views and visitors, counted on this server.'}
+    {name: 'analytics', displayName: 'Analytics', icon: 'chart-bar', description: 'Page views and visitors, counted on this server.'},
+    {name: 'seo', displayName: 'SEO', icon: 'search', description: 'How the site looks to search engines: an audit of every page, redirects, the sitemap and robots.txt.'}
 ]);
 
 const CORE_NAMES = new Set(CORE_TOOLS.map(t => t.name));