domma-cms 0.5.4 → 0.6.0

package/bin/cli.js

@@ -37,21 +37,44 @@ const positional = args.filter(a => !a.startsWith('--'));
 
 if (flags.has('--help') || args.includes('-h')) {
   console.log(`
-  Usage: npx domma-cms <project-name> [options]
+  Usage: npx domma-cms <command> [options]
 
-  Options:
+  Commands:
+    <project-name>   Scaffold a new Domma CMS project
+    update           Update an existing project to the latest version
+
+  Scaffold options:
     --no-install   Skip npm install
     --no-setup     Skip the interactive setup wizard
     --no-seed      Skip seeding default pages, forms, and collections
     --help         Show this help message
 
-  Example:
+  Update options:
+    --yes          Skip confirmation prompt
+    --no-backup    Skip creating a backup before updating
+    --no-install   Skip npm install after updating
+    --dry-run      Preview what would change without writing anything
+
+  Examples:
     npx domma-cms my-blog
     npx domma-cms my-blog --no-install --no-setup
+    npx domma-cms update
+    npx domma-cms update --dry-run
+    npx domma-cms update --yes --no-backup
 `);
   process.exit(0);
 }
 
+// ---------------------------------------------------------------------------
+// Route subcommands
+// ---------------------------------------------------------------------------
+
+if (positional[0] === 'update') {
+  const {default: runUpdate} = await import('./update.js');
+  await runUpdate(positional.slice(1), flags);
+  process.exit(0);
+}
+
 const projectName = positional[0];
 
 if (!projectName) {
@@ -292,6 +315,7 @@ const GITIGNORE = `node_modules/
 content/users/
 content/media/
 *.log
+.domma-backups/
 `;
 
 step('Writing .gitignore');
@@ -351,6 +375,19 @@ if (noSeed) {
   console.log('');
 }
 
+// ---------------------------------------------------------------------------
+// Write .domma version marker
+// ---------------------------------------------------------------------------
+
+step('Writing .domma marker');
+const marker = {
+  cmsVersion: sourcePkg.version,
+  scaffoldedAt: new Date().toISOString(),
+  lastUpdatedAt: null
+};
+writeFileSync(path.join(target, '.domma'), JSON.stringify(marker, null, 2) + '\n', 'utf8');
+done();
+
 // ---------------------------------------------------------------------------
 // Success
 // ---------------------------------------------------------------------------

package/bin/lib/config-merge.js

@@ -0,0 +1,44 @@
+/**
+ * Domma CMS — Config Merge Utility
+ * Merges new keys from an upstream config into an existing user config,
+ * without ever overwriting values the user already has.
+ */
+
+/**
+ * Deep-merge new keys from `upstream` into `existing`.
+ * Existing values are never modified — only missing keys are added.
+ *
+ * @param {object} existing - The user's current config object
+ * @param {object} upstream - The upstream (new version) config object
+ * @param {string} [_prefix] - Internal: key path prefix for reporting
+ * @returns {{ merged: object, added: string[] }} Merged object + list of added key paths
+ */
+export function deepMergeNewKeys(existing, upstream, _prefix = '') {
+    const merged = {...existing};
+    const added = [];
+
+    for (const [key, upstreamVal] of Object.entries(upstream)) {
+        const fullKey = _prefix ? `${_prefix}.${key}` : key;
+
+        if (!(key in existing)) {
+            // Key is entirely missing — add it wholesale
+            merged[key] = upstreamVal;
+            added.push(fullKey);
+        } else if (
+            upstreamVal !== null &&
+            typeof upstreamVal === 'object' &&
+            !Array.isArray(upstreamVal) &&
+            typeof existing[key] === 'object' &&
+            existing[key] !== null &&
+            !Array.isArray(existing[key])
+        ) {
+            // Both sides are plain objects — recurse
+            const child = deepMergeNewKeys(existing[key], upstreamVal, fullKey);
+            merged[key] = child.merged;
+            added.push(...child.added);
+        }
+        // Otherwise: existing value wins — no action
+    }
+
+    return {merged, added};
+}

package/bin/update.js

@@ -0,0 +1,542 @@
+#!/usr/bin/env node
+/**
+ * Domma CMS — Project Update
+ * Usage: npx domma-cms update [--yes] [--no-backup] [--no-install] [--dry-run]
+ *
+ * Run from inside an existing Domma CMS project directory.
+ * Pulls upstream changes from the installed CLI package into the project,
+ * preserving all user content, config, and custom plugins.
+ */
+
+import {cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync,} from 'node:fs';
+import {spawnSync} from 'node:child_process';
+import path from 'node:path';
+import {createInterface} from 'node:readline';
+import {fileURLToPath} from 'node:url';
+import {deepMergeNewKeys} from './lib/config-merge.js';
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function step(label) {
+    process.stdout.write(`  ${label}…`);
+}
+
+function done(note = '') {
+    console.log(note ? ` done. ${note}` : ' done.');
+}
+
+function info(msg) {
+    console.log(`  ${msg}`);
+}
+
+function warn(msg) {
+    console.log(`  ⚠  ${msg}`);
+}
+
+function readJson(filePath) {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, obj) {
+    writeFileSync(filePath, JSON.stringify(obj, null, 4) + '\n', 'utf8');
+}
+
+/**
+ * Prompt the user for a yes/no confirmation.
+ * @param {string} question
+ * @returns {Promise<boolean>}
+ */
+function confirm(question) {
+    return new Promise(resolve => {
+        const rl = createInterface({input: process.stdin, output: process.stdout});
+        rl.question(`  ${question} [y/N] `, answer => {
+            rl.close();
+            resolve(/^y(es)?$/i.test(answer.trim()));
+        });
+    });
+}
+
+/**
+ * Recursively list all relative file paths under a directory.
+ * @param {string} dir - Absolute directory path
+ * @param {string} [base] - Base path for relative output (defaults to dir)
+ * @returns {string[]}
+ */
+function listFiles(dir, base = dir) {
+    if (!existsSync(dir)) return [];
+    const result = [];
+    for (const entry of readdirSync(dir, {withFileTypes: true})) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            result.push(...listFiles(full, base));
+        } else {
+            result.push(path.relative(base, full));
+        }
+    }
+    return result;
+}
+
+// ---------------------------------------------------------------------------
+// Upstream dirs that are fully replaced on update
+// ---------------------------------------------------------------------------
+
+const UPSTREAM_DIRS = ['server', 'admin', 'public', 'scripts'];
+
+// ---------------------------------------------------------------------------
+// Structural config files that get new-key merging (never full replace)
+// ---------------------------------------------------------------------------
+
+const STRUCTURAL_CONFIGS = [
+    'config/server.json',
+    'config/auth.json',
+    'config/content.json',
+    'config/presets.json',
+];
+
+// ---------------------------------------------------------------------------
+// Main update function
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {string[]} _positional - Remaining positional args (unused)
+ * @param {Set<string>} flags - Parsed CLI flags
+ */
+export default async function update(_positional, flags) {
+    const isDryRun = flags.has('--dry-run');
+    const skipConfirm = flags.has('--yes');
+    const skipBackup = flags.has('--no-backup');
+    const skipInstall = flags.has('--no-install');
+
+    const cwd = process.cwd();
+
+    // -------------------------------------------------------------------------
+    // 1. Detect project
+    // -------------------------------------------------------------------------
+
+    console.log('');
+    console.log('  ┌──────────────────────────────────────────┐');
+    console.log('  │                                          │');
+    console.log('  │   Domma CMS — Project Updater           │');
+    console.log('  │                                          │');
+    console.log('  └──────────────────────────────────────────┘');
+    console.log('');
+
+    // Refuse to run inside the CLI package itself
+    if (path.resolve(cwd) === path.resolve(PACKAGE_ROOT)) {
+        console.error('  ✗ Run this command from inside your scaffolded project, not the CLI package.\n');
+        process.exit(1);
+    }
+
+    const requiredFiles = ['package.json', 'server/server.js', 'config'];
+    for (const f of requiredFiles) {
+        if (!existsSync(path.join(cwd, f))) {
+            console.error(`  ✗ Not a Domma CMS project directory (missing ${f}).\n`);
+            console.error('  Run this command from inside your project folder.\n');
+            process.exit(1);
+        }
+    }
+
+    // Scaffolded projects are always private — reject if not
+    try {
+        const cwdPkg = readJson(path.join(cwd, 'package.json'));
+        if (!cwdPkg.private) {
+            console.error('  ✗ This does not appear to be a scaffolded Domma CMS project (package.json is not private).\n');
+            process.exit(1);
+        }
+    } catch { /* malformed package.json — let it proceed */
+    }
+
+    // -------------------------------------------------------------------------
+    // 2. Read version information
+    // -------------------------------------------------------------------------
+
+    const markerPath = path.join(cwd, '.domma');
+    let installedVersion = 'unknown';
+    let markerData = null;
+
+    if (existsSync(markerPath)) {
+        try {
+            markerData = readJson(markerPath);
+            installedVersion = markerData.cmsVersion ?? 'unknown';
+        } catch {
+            warn('Could not read .domma marker — treating as unknown version.');
+        }
+    } else {
+        warn('No .domma marker found. This project was scaffolded before version tracking was introduced.');
+        warn('The updater will proceed, but cannot guarantee what was previously installed.');
+        console.log('');
+    }
+
+    const sourcePkg = readJson(path.join(PACKAGE_ROOT, 'package.json'));
+    const incomingVersion = sourcePkg.version;
+
+    info(`Current:   ${installedVersion}`);
+    info(`Available: ${incomingVersion}`);
+    console.log('');
+
+    if (installedVersion !== 'unknown' && installedVersion === incomingVersion) {
+        info('✓ Already up to date.');
+        console.log('');
+        process.exit(0);
+    }
+
+    // -------------------------------------------------------------------------
+    // 3. Dry-run mode — preview changes and exit
+    // -------------------------------------------------------------------------
+
+    if (isDryRun) {
+        info('Dry run — no files will be modified.\n');
+
+        info('Upstream directories that would be replaced:');
+        for (const dir of UPSTREAM_DIRS) {
+            info(`  → ${dir}/`);
+        }
+        console.log('');
+
+        info('Structural configs that would be merged (new keys only):');
+        for (const cfg of STRUCTURAL_CONFIGS) {
+            if (existsSync(path.join(cwd, cfg))) {
+                const existing = readJson(path.join(cwd, cfg));
+                const upstream = existsSync(path.join(PACKAGE_ROOT, cfg))
+                    ? readJson(path.join(PACKAGE_ROOT, cfg))
+                    : {};
+                const {added} = deepMergeNewKeys(existing, upstream);
+                if (added.length > 0) {
+                    info(`  ${cfg}: would add ${added.length} key(s): ${added.join(', ')}`);
+                } else {
+                    info(`  ${cfg}: no new keys`);
+                }
+            }
+        }
+        console.log('');
+
+        info('Plugins that would be updated:');
+        const pluginsDirSrc = path.join(PACKAGE_ROOT, 'plugins');
+        const pluginsDirDst = path.join(cwd, 'plugins');
+        if (existsSync(pluginsDirSrc)) {
+            const upstreamPlugins = readdirSync(pluginsDirSrc, {withFileTypes: true})
+                .filter(e => e.isDirectory())
+                .map(e => e.name);
+            for (const name of upstreamPlugins) {
+                const exists = existsSync(path.join(pluginsDirDst, name));
+                info(`  → plugins/${name}/ (${exists ? 'update' : 'add'})`);
+            }
+        }
+        console.log('');
+
+        info('Package.json: CMS deps would be replaced; user-added deps preserved.');
+        console.log('');
+        process.exit(0);
+    }
+
+    // -------------------------------------------------------------------------
+    // 4. Confirmation prompt
+    // -------------------------------------------------------------------------
+
+    if (!skipConfirm) {
+        const confirmed = await confirm(`Update project from ${installedVersion} to ${incomingVersion}?`);
+        if (!confirmed) {
+            info('Update cancelled.');
+            console.log('');
+            process.exit(0);
+        }
+        console.log('');
+    }
+
+    // -------------------------------------------------------------------------
+    // 5. Backup
+    // -------------------------------------------------------------------------
+
+    let backupPath = null;
+
+    if (!skipBackup) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        backupPath = path.join(cwd, '.domma-backups', timestamp);
+        step('Creating backup');
+        mkdirSync(backupPath, {recursive: true});
+
+        // Back up upstream dirs
+        for (const dir of UPSTREAM_DIRS) {
+            const src = path.join(cwd, dir);
+            if (existsSync(src)) {
+                cpSync(src, path.join(backupPath, dir), {recursive: true});
+            }
+        }
+
+        // Back up package.json and structural configs
+        for (const f of ['package.json', ...STRUCTURAL_CONFIGS]) {
+            const src = path.join(cwd, f);
+            if (existsSync(src)) {
+                const dest = path.join(backupPath, f);
+                mkdirSync(path.dirname(dest), {recursive: true});
+                cpSync(src, dest);
+            }
+        }
+
+        // Back up plugins dir (code only, not data)
+        const pluginsDir = path.join(cwd, 'plugins');
+        if (existsSync(pluginsDir)) {
+            cpSync(pluginsDir, path.join(backupPath, 'plugins'), {recursive: true});
+        }
+
+        done();
+    } else {
+        warn('Skipping backup (--no-backup).');
+    }
+
+    // -------------------------------------------------------------------------
+    // 6. Replace upstream directories
+    // -------------------------------------------------------------------------
+
+    step('Replacing upstream code');
+    for (const dir of UPSTREAM_DIRS) {
+        const dest = path.join(cwd, dir);
+        const src = path.join(PACKAGE_ROOT, dir);
+        if (!existsSync(src)) continue;
+        if (existsSync(dest)) rmSync(dest, {recursive: true, force: true});
+        cpSync(src, dest, {recursive: true});
+    }
+    done();
+
+    // -------------------------------------------------------------------------
+    // 7. Update plugins
+    // -------------------------------------------------------------------------
+
+    step('Updating plugins');
+    const pluginsDirSrc = path.join(PACKAGE_ROOT, 'plugins');
+    const pluginsDirDst = path.join(cwd, 'plugins');
+    const newPlugins = [];
+
+    if (existsSync(pluginsDirSrc)) {
+        mkdirSync(pluginsDirDst, {recursive: true});
+        const upstreamPlugins = readdirSync(pluginsDirSrc, {withFileTypes: true})
+            .filter(e => e.isDirectory())
+            .map(e => e.name);
+
+        for (const name of upstreamPlugins) {
+            const srcPlugin = path.join(pluginsDirSrc, name);
+            const dstPlugin = path.join(pluginsDirDst, name);
+            const isNew = !existsSync(dstPlugin);
+
+            if (isNew) {
+                // Brand-new plugin — copy wholesale, apply scaffold.reset
+                cpSync(srcPlugin, dstPlugin, {recursive: true});
+                try {
+                    const manifest = readJson(path.join(dstPlugin, 'plugin.json'));
+                    for (const {path: relPath, content} of (manifest.scaffold?.reset ?? [])) {
+                        const absPath = path.join(dstPlugin, relPath);
+                        mkdirSync(path.dirname(absPath), {recursive: true});
+                        writeFileSync(absPath, content + '\n', 'utf8');
+                    }
+                } catch { /* no manifest — skip reset */
+                }
+                newPlugins.push(name);
+            } else {
+                // Existing plugin — identify paths to preserve
+                let preservePaths = new Set(['data']);
+                try {
+                    const manifest = readJson(path.join(srcPlugin, 'plugin.json'));
+                    for (const {path: relPath} of (manifest.scaffold?.reset ?? [])) {
+                        preservePaths.add(relPath);
+                    }
+                } catch { /* no manifest */
+                }
+
+                // Back up preserved paths from current install
+                const preserved = new Map();
+                for (const rel of preservePaths) {
+                    const abs = path.join(dstPlugin, rel);
+                    if (!existsSync(abs)) continue;
+
+                    if (statSync(abs).isDirectory()) {
+                        // Preserve all files under this directory
+                        for (const f of listFiles(abs, dstPlugin)) {
+                            preserved.set(f, readFileSync(path.join(dstPlugin, f)));
+                        }
+                    } else {
+                        // scaffold.reset entry — preserve the single file
+                        preserved.set(rel, readFileSync(abs));
+                    }
+                }
+
+                // Replace plugin directory with upstream
+                rmSync(dstPlugin, {recursive: true, force: true});
+                cpSync(srcPlugin, dstPlugin, {recursive: true});
+
+                // Restore preserved files
+                for (const [rel, content] of preserved) {
+                    const abs = path.join(dstPlugin, rel);
+                    mkdirSync(path.dirname(abs), {recursive: true});
+                    writeFileSync(abs, content);
+                }
+            }
+        }
+    }
+    done();
+
+    // -------------------------------------------------------------------------
+    // 8. Register new plugins in plugins.json (disabled by default)
+    // -------------------------------------------------------------------------
+
+    const pluginsJsonPath = path.join(cwd, 'config/plugins.json');
+    if (newPlugins.length > 0 && existsSync(pluginsJsonPath)) {
+        try {
+            const pluginsCfg = readJson(pluginsJsonPath);
+            for (const name of newPlugins) {
+                if (!(name in pluginsCfg)) {
+                    pluginsCfg[name] = {enabled: false, settings: {}};
+                }
+            }
+            writeJson(pluginsJsonPath, pluginsCfg);
+        } catch { /* if plugins.json is malformed, skip */
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // 9. Merge structural configs (new keys only)
+    // -------------------------------------------------------------------------
+
+    step('Merging structural configs');
+    const mergedKeys = {};
+
+    for (const cfgFile of STRUCTURAL_CONFIGS) {
+        const dstPath = path.join(cwd, cfgFile);
+        const srcPath = path.join(PACKAGE_ROOT, cfgFile);
+        if (!existsSync(dstPath) || !existsSync(srcPath)) continue;
+
+        try {
+            const existing = readJson(dstPath);
+            const upstream = readJson(srcPath);
+            const {merged, added} = deepMergeNewKeys(existing, upstream);
+            if (added.length > 0) {
+                writeJson(dstPath, merged);
+                mergedKeys[cfgFile] = added;
+            }
+        } catch { /* malformed JSON — skip */
+        }
+    }
+    done();
+
+    // -------------------------------------------------------------------------
+    // 10. Update package.json: replace CMS deps, preserve user-added deps
+    // -------------------------------------------------------------------------
+
+    step('Updating package.json');
+    const projectPkgPath = path.join(cwd, 'package.json');
+    try {
+        const projectPkg = readJson(projectPkgPath);
+        const cmsDeps = sourcePkg.dependencies ?? {};
+        const cmsOptional = sourcePkg.optionalDependencies ?? {};
+        const userDeps = projectPkg.dependencies ?? {};
+
+        // Preserve deps the user added (not in CMS deps at time of scaffold)
+        // We identify "user-added" as: present in project but not in the new upstream CMS deps
+        const userAddedDeps = {};
+        for (const [pkg, ver] of Object.entries(userDeps)) {
+            if (!(pkg in cmsDeps) && !(pkg in cmsOptional)) {
+                userAddedDeps[pkg] = ver;
+            }
+        }
+
+        // Replace CMS scripts, but never copy prepublishOnly
+        const newScripts = {...sourcePkg.scripts};
+        delete newScripts.prepublishOnly;
+
+        projectPkg.dependencies = {...cmsDeps, ...userAddedDeps};
+        projectPkg.optionalDependencies = cmsOptional;
+        projectPkg.scripts = newScripts;
+
+        writeFileSync(projectPkgPath, JSON.stringify(projectPkg, null, 2) + '\n', 'utf8');
+    } catch { /* malformed package.json — skip */
+    }
+    done();
+
+    // -------------------------------------------------------------------------
+    // 11. Ensure .domma-backups/ is in .gitignore
+    // -------------------------------------------------------------------------
+
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const backupEntry = '.domma-backups/';
+    if (existsSync(gitignorePath)) {
+        const current = readFileSync(gitignorePath, 'utf8');
+        if (!current.includes(backupEntry)) {
+            writeFileSync(gitignorePath, current.trimEnd() + '\n' + backupEntry + '\n', 'utf8');
+        }
+    } else {
+        writeFileSync(gitignorePath, backupEntry + '\n', 'utf8');
+    }
+
+    // -------------------------------------------------------------------------
+    // 12. Write updated .domma marker
+    // -------------------------------------------------------------------------
+
+    step('Updating .domma marker');
+    const newMarker = {
+        cmsVersion: incomingVersion,
+        scaffoldedAt: markerData?.scaffoldedAt ?? null,
+        lastUpdatedAt: new Date().toISOString(),
+    };
+    writeFileSync(markerPath, JSON.stringify(newMarker, null, 2) + '\n', 'utf8');
+    done();
+
+    // -------------------------------------------------------------------------
+    // 13. npm install
+    // -------------------------------------------------------------------------
+
+    console.log('');
+
+    if (skipInstall) {
+        warn('Skipping npm install (--no-install).');
+    } else {
+        info('Running npm install…');
+        console.log('');
+        const result = spawnSync('npm', ['install'], {cwd, stdio: 'inherit'});
+        if (result.status !== 0) {
+            console.error('\n  ✗ npm install failed.\n');
+            process.exit(result.status ?? 1);
+        }
+        console.log('');
+    }
+
+    // -------------------------------------------------------------------------
+    // 14. Summary
+    // -------------------------------------------------------------------------
+
+    console.log('  ┌──────────────────────────────────────────┐');
+    console.log('  │   ✓ Update complete!                     │');
+    console.log('  └──────────────────────────────────────────┘');
+    console.log('');
+
+    info(`  ${installedVersion}  →  ${incomingVersion}`);
+    console.log('');
+
+    if (backupPath) {
+        info(`Backup saved to: .domma-backups/${path.basename(backupPath)}/`);
+    }
+
+    if (newPlugins.length > 0) {
+        info(`New plugins added (disabled by default): ${newPlugins.join(', ')}`);
+    }
+
+    const allMergedKeys = Object.entries(mergedKeys);
+    if (allMergedKeys.length > 0) {
+        info('New config keys added:');
+        for (const [file, keys] of allMergedKeys) {
+            info(`  ${file}: ${keys.join(', ')}`);
+        }
+    }
+
+    console.log('');
+    info('Restart your dev server to apply changes:  npm run dev');
+    console.log('');
+}

package/config/server.json

@@ -1,6 +1,10 @@
-{
-  "port": 4096,
-    "host": "0.0.0.0",
-    "cors": { "origin": false },
-    "uploads": { "maxFileSize": 10485760 }
-}
+{
+  "port": 4096,
+    "host": "0.0.0.0",
+  "cors": {
+    "origin": false
+  },
+  "uploads": {
+    "maxFileSize": 10485760
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domma-cms",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "File-based CMS powered by Domma and Fastify. Run npx domma-cms my-site to create a new project.",
   "type": "module",
   "main": "server/server.js",