@geekity/cms 0.31.0 → 0.32.0

package/dist/cli.js

@@ -10,22 +10,32 @@ import { credentialProblem, emailProblem } from './admin/credentials.js';
 import { migrateUsersToFile } from './admin/legacy-migrations.js';
 import { adminStoreOwning, openAdminDatabase } from './store/admin-store.js';
 import { databaseFile, discardDatabase } from './cache.js';
-import { CONFIG_FILENAMES, loadResolvedConfig } from './config-loader.js';
+import { CONTENT_SCRATCH_FILES, dataPath } from './files/data-files.js';
+import { compactTime, exportFileName, planSiteExport, writeSiteExport, } from './export/site-export.js';
+import { checkImportTargets, discardStaging, finishSiteImport, importNotes, installArchivedPlugins, placeSiteImport, pluginFailureLine, readSiteManifest, restoreEnabledPlugins, stageSiteImport, } from './export/site-import.js';
+import { CONFIG_FILENAMES, loadConfig, loadResolvedConfig } from './config-loader.js';
+import { resolveConfig } from './config.js';
 import { migrateCommentEmails, migrateCommentKeys } from './comments/migrations.js';
-import { stripStoredUploads } from './content/metadata/sweep.js';
+import { STRIP_METADATA_JOB } from './content/metadata/strip-job.js';
+import { RESEND_JOB } from './federation/resend-job.js';
 import { createUser, DuplicateUsernameError } from './site/users.js';
-import { UPLOAD_DIRECTORY } from './content/uploads.js';
-import { createCms } from './index.js';
+import { createCms, settleConfig } from './index.js';
 import { initSite, ownManifest, seedStarterContent } from './init.js';
+import { finishedResult } from './jobs/types.js';
 import { importPluginFolders, scanPluginFolders } from './plugins/folder.js';
 import { ADD_WITH_COMMAND, addPlugin, installedFolders, parsePackageSpec, pluginRegistry, removePlugin, requirementNotes, } from './plugins/install.js';
 import { describeUpgrade, upgradePlugins } from './plugins/upgrade.js';
+import { migratePluginSettings } from './plugins/migrate-settings.js';
+import { siteDataFiles } from './plugins/data.js';
+import { readEnabledPlugins } from './plugins/enabled.js';
 import { pluginSite, sitePluginRegistry } from './plugins/site.js';
-import { askToReload } from './supervisor/control.js';
+import { askToReload, isServing } from './supervisor/control.js';
 import { superviseCluster } from './supervisor/primary.js';
 import { processChannel, superviseWorker } from './supervisor/worker.js';
-import { enterMaintenance, leaveMaintenance, maintenanceFile, readMaintenance, } from './maintenance.js';
-import { devModeOn, enterDevMode, leaveDevMode } from './dev-mode.js';
+import { DEV_MODE, DEV_MODE_LATCHED } from './settings/dev-mode.js';
+import { MAINTENANCE, MAINTENANCE_FILE } from './settings/maintenance.js';
+import { overridden, sourceLabel } from './settings/registry.js';
+import { createSettings } from './site/namespace.js';
 import { messageOf } from './util/errors.js';
 const COMMANDS = {
     serve: {
@@ -106,6 +116,45 @@ const COMMANDS = {
         ],
         run: devModeCommand,
     },
+    settings: {
+        synopsis: [
+            'settings list [<namespace>] [--config <file>]',
+            'settings get <namespace.key> [--config <file>]',
+            'settings set <namespace.key> (<value> | --unset) [--config <file>]',
+            'settings migrate-plugins [--config <file>]',
+        ],
+        help: [
+            [
+                'settings list',
+                [
+                    'Print every runtime setting: its value in effect, where',
+                    'that value came from (env, config, file or default) and',
+                    'what it does. A secret prints as (set) or (not set).',
+                    "Each running plugin's settings follow the core ones, as",
+                    '@geekity/plugin-llm.default_model.',
+                ],
+            ],
+            ['settings get', ['Print one value in effect, and what overrides it, if', 'anything.']],
+            [
+                'settings set',
+                [
+                    'Store one value, or remove it with --unset so the default',
+                    'applies. A setting the environment or the config overrides',
+                    'is refused. A secret set here is left in the shell history.',
+                ],
+            ],
+            [
+                'settings migrate-plugins',
+                [
+                    "Move each plugin's settings out of content/_data/site.json",
+                    'into data/plugins/<name>/settings.json, keeping enabled',
+                    'where it is. A server does this when it starts; run it',
+                    'with the site stopped to do it first. Safe to run twice.',
+                ],
+            ],
+        ],
+        run: settingsCommand,
+    },
     'strip-metadata': {
         synopsis: ['strip-metadata [--config <file>]'],
         help: [
@@ -122,6 +171,45 @@ const COMMANDS = {
         ],
         run: stripMetadataCommand,
     },
+    export: {
+        synopsis: [
+            'export [--out <file>] [--with-credentials] [--without-content] [--list] [--config <file>]',
+        ],
+        help: [
+            [
+                'export',
+                [
+                    'Write the site to a .tar.gz: content/ and every file in',
+                    'data/ the site cannot rebuild, with manifest.json first.',
+                    'Credentials are left out unless --with-credentials is given.',
+                    'It only reads, so it runs while the site serves. It prints',
+                    'the deliveries waiting in the queue, which are never',
+                    'exported. --list prints what each file in data/ is and',
+                    'writes nothing.',
+                ],
+            ],
+        ],
+        run: exportCommand,
+    },
+    import: {
+        synopsis: ['import <file> [--replace] [--dev-mode] [--new-base-url] [--config <file>]'],
+        help: [
+            [
+                'import',
+                [
+                    'Restore a site from an archive geekity export wrote, with the',
+                    'site stopped. Every file is checked against the manifest and',
+                    'unpacked beside content/ and data/ before it replaces them.',
+                    'Folder plugins are installed from the npm registry at the',
+                    'versions the archive records, and the database is rebuilt.',
+                    'It exits 1 when a plugin could not be installed, naming it',
+                    'and the command to retry.',
+                ],
+            ],
+        ],
+        sharedWithPlugins: true,
+        run: importCommand,
+    },
     user: {
         synopsis: ['user add <username> [--password <pw>] [--email <address>] [--config <file>]'],
         help: [
@@ -175,9 +263,19 @@ const COMMANDS = {
  * The options one command reads out of {@link ParsedArgs.flags}, each of which
  * carries a value.
  */
-const VALUE_FLAGS = ['until'];
+const VALUE_FLAGS = ['until', 'out'];
 /** The options that are simply on or off. */
-const SWITCH_FLAGS = ['all', 'check'];
+const SWITCH_FLAGS = [
+    'all',
+    'check',
+    'unset',
+    'with-credentials',
+    'without-content',
+    'list',
+    'replace',
+    'dev-mode',
+    'new-base-url',
+];
 const OPTIONS_HELP = `Options:
   --config <file>  Config file to load. Defaults to the first of
                    ${CONFIG_FILENAMES.join(', ')} found in the working directory.
@@ -191,8 +289,24 @@ const OPTIONS_HELP = `Options:
                    ISO 8601 time such as 2026-09-28T14:00:00Z. It is the
                    Retry-After a client is sent, and the maintenance page
                    says it.
+  --unset          With settings set: remove the stored value.
   --all            With resend: every announced post rather than named ones.
   --check          With plugin upgrade: say what would change, install nothing.
+  --out <file>     With export: the archive to write. Defaults to
+                   geekity-<host>-<time>.tar.gz in the working directory.
+  --with-credentials
+                   With export: include the API keys and logins kept in
+                   data/ (mail.json, akismet.json, each plugin's secrets).
+  --without-content
+                   With export: leave content/ out.
+  --list           With export: print each file data/ may hold, its class
+                   and what is lost without it, and write nothing.
+  --replace        With import: move what content/ and data/ hold into
+                   <dir>/.geekity-before-import-<time> when they hold a site.
+  --dev-mode       With import: turn dev mode on, for a staging copy of a
+                   live site.
+  --new-base-url   With import: accept a base URL in effect that differs
+                   from the one the archive was exported from.
   -h, --help       Show this help.
   -v, --version    Show the installed version.
 
@@ -314,9 +428,12 @@ function isCommand(value) {
 }
 /** Run one command. Resolves with the exit code the process should use. */
 async function main(argv) {
-    const first = leadingWords(argv)[0];
-    if (first !== undefined && !isCommand(first) && !argv.some(isHelpOrVersion)) {
-        return await pluginCommand(argv);
+    const words = leadingWords(argv);
+    const first = words[0];
+    if (first !== undefined && !argv.some(isHelpOrVersion)) {
+        if (!isCommand(first) || (await pluginExtends(first, words, configFlag(argv)))) {
+            return await pluginCommand(argv);
+        }
     }
     const parsed = parseArgs(argv);
     if (parsed.command === 'help') {
@@ -348,34 +465,33 @@ async function initCommand({ args }) {
     ].join('\n'));
     return 0;
 }
-/**
- * `geekity maintenance on|off|status` (TASK-130).
- *
- * Only the file under `data/` is touched, so this works the same with the
- * site running or stopped: a running site re-reads it within a second.
- */
 async function maintenanceCommand({ args, configPath, flags }) {
     const action = args[0];
     const config = await loadResolvedConfig(configPath);
-    const file = maintenanceFile(config.dataDir);
+    const settings = createSettings({ config });
     if (action === 'on') {
         const until = untilFlag(text(flags, 'until'));
-        await enterMaintenance(config.dataDir, { until });
+        await setOrThrow(settings, 'maintenance', { on: true, until: until?.toISOString() ?? '' });
+        const file = dataPath(config.dataDir, MAINTENANCE_FILE);
         process.stdout.write(`Maintenance mode is on (${file}).${untilLine(until)}\n`);
         return 0;
     }
     if (action === 'off') {
-        await leaveMaintenance(config.dataDir);
-        process.stdout.write(`Maintenance mode is off.${forcedLine(config.maintenance)}\n`);
+        if (overridden((await settings.resolve(MAINTENANCE.on)).source)) {
+            throw new Error(`Maintenance mode is still on.${forcedLine(true)}`);
+        }
+        await setOrThrow(settings, 'maintenance', { on: false });
+        process.stdout.write('Maintenance mode is off.\n');
         return 0;
     }
     if (action === 'status') {
-        const window = readMaintenance(config.dataDir);
-        if (window === undefined && !config.maintenance) {
+        const on = await settings.resolve(MAINTENANCE.on);
+        if (!on.value) {
             process.stdout.write('Maintenance mode is off.\n');
         }
         else {
-            process.stdout.write(`Maintenance mode is on.${untilLine(window?.until)}${forcedLine(config.maintenance)}\n`);
+            const until = await settings.get(MAINTENANCE.until);
+            process.stdout.write(`Maintenance mode is on.${untilLine(until === '' ? undefined : new Date(until))}${forcedLine(overridden(on.source))}\n`);
         }
         return 0;
     }
@@ -384,28 +500,170 @@ async function maintenanceCommand({ args, configPath, flags }) {
 async function devModeCommand({ args, configPath }) {
     const action = args[0];
     const config = await loadResolvedConfig(configPath);
+    const settings = createSettings({ config });
     if (action === 'on') {
-        enterDevMode(config.dataDir, 'command', config.now());
+        await setOrThrow(settings, 'dev_mode', { on: true });
         process.stdout.write('Dev mode is on: nothing the site does is sent until `geekity dev-mode off`.\n');
         return 0;
     }
     if (action === 'off') {
         if (config.devMode) {
-            throw new Error('GEEKITY_DEV_MODE or the devMode setting still asks for dev mode. ' +
-                'Remove it, then run geekity dev-mode off again.');
+            throw new Error(`${DEV_MODE_LATCHED} Remove it, then run geekity dev-mode off again.`);
         }
-        const wasOn = leaveDevMode(config.dataDir, config.now());
+        const wasOn = await settings.get(DEV_MODE.on);
+        await setOrThrow(settings, 'dev_mode', { on: false });
         process.stdout.write(wasOn
             ? 'Dev mode is off: the site is live. Nothing held while it was on will be sent.\n'
             : 'Dev mode was already off: the site is live.\n');
         return 0;
     }
     if (action === 'status') {
-        process.stdout.write(devModeOn(config) ? 'Dev mode is on.\n' : 'Dev mode is off.\n');
+        process.stdout.write((await settings.get(DEV_MODE.on)) ? 'Dev mode is on.\n' : 'Dev mode is off.\n');
         return 0;
     }
     throw new Error('geekity dev-mode needs on, off or status.');
 }
+async function settingsCommand({ args, configPath, flags }) {
+    const [action, name, value] = args;
+    const config = await loadResolvedConfig(configPath);
+    if (action === 'migrate-plugins' && name === undefined) {
+        const moved = migratePluginSettings({
+            contentDir: config.contentDir,
+            dataDir: config.dataDir,
+            log: (line) => process.stdout.write(`${line}\n`),
+        });
+        if (moved.length === 0) {
+            process.stdout.write('No plugin settings are left in content/_data/site.json.\n');
+        }
+        return 0;
+    }
+    const request = settingsRequest(action, name, value, flags['unset'] === true);
+    if (request === undefined) {
+        throw new Error('geekity settings needs list [<namespace>], get <namespace.key>, set <namespace.key> with a value or --unset, or migrate-plugins.');
+    }
+    const settings = await settingsWithRunningPlugins(config);
+    if (request.action === 'list') {
+        const refs = settings.list().filter((ref) => name === undefined || ref.namespace === name);
+        if (refs.length === 0)
+            throw new Error(`There is no settings namespace ${String(name)}.`);
+        const rows = await Promise.all(refs.map((ref) => settingRow(settings, ref)));
+        process.stdout.write(table(rows));
+        return 0;
+    }
+    const ref = settingNamed(settings, request.name);
+    if (request.action === 'get') {
+        const resolved = await settings.resolve(ref);
+        const lines = [shown(ref, resolved.value)];
+        if (overridden(resolved.source)) {
+            const held = resolved.stored === undefined ? 'nothing' : shown(ref, resolved.stored);
+            lines.push(`overridden by ${sourceLabel(resolved.source)}; the file holds ${held}`);
+        }
+        process.stdout.write(`${lines.join('\n')}\n`);
+        return 0;
+    }
+    const { type } = ref.declaration;
+    let stored;
+    if (request.value !== undefined) {
+        const parsed = type.fromText(request.value);
+        if (!parsed.ok)
+            throw new Error(`${request.name} ${parsed.problem}.`);
+        stored = type.toJson(parsed.value);
+    }
+    await setOrThrow(settings, ref.namespace, { [ref.key]: stored });
+    process.stdout.write(table([await settingRow(settings, ref)]));
+    return 0;
+}
+function settingsRequest(action, name, value, unset) {
+    if (action === 'list')
+        return { action };
+    if (name === undefined)
+        return undefined;
+    if (action === 'get')
+        return { action, name };
+    if (action === 'set' && (value !== undefined) !== unset)
+        return { action, name, value };
+    return undefined;
+}
+async function settingsWithRunningPlugins(config) {
+    migratePluginSettings({
+        contentDir: config.contentDir,
+        dataDir: config.dataDir,
+        log: (line) => process.stderr.write(`${line}\n`),
+    });
+    const settings = createSettings({ config });
+    let registry;
+    try {
+        registry = await loadSitePlugins(config, settings);
+    }
+    catch (error) {
+        process.stderr.write(`Plugin settings are not listed: ${messageOf(error)}\n`);
+        return settings;
+    }
+    const enabled = readEnabledPlugins(config.contentDir);
+    const running = registry.active(enabled);
+    for (const entry of registry.plugins) {
+        const { name } = entry.plugin;
+        const declared = entry.settingsNamespace !== undefined;
+        const unremarkable = !declared && !enabled.has(name) && entry.problem === undefined;
+        if (running.has(name) || unremarkable)
+            continue;
+        const unlisted = declared ? ' Its settings are not listed.' : '';
+        process.stderr.write(`${name} ${whyNotRunning(entry, enabled)}${unlisted}\n`);
+        if (declared)
+            settings.unregister(name);
+    }
+    return settings;
+}
+function whyNotRunning(entry, enabled) {
+    if (entry.problem !== undefined)
+        return `did not load: ${entry.problem}`;
+    if (enabled.has(entry.plugin.name)) {
+        return 'is enabled but not running, because a plugin it requires is not running.';
+    }
+    return 'is installed but not enabled.';
+}
+function settingNamed(settings, name) {
+    const dot = name.lastIndexOf('.');
+    const found = settings
+        .list()
+        .find((ref) => ref.namespace === name.slice(0, dot) && ref.key === name.slice(dot + 1));
+    if (found === undefined) {
+        throw new Error(`There is no setting ${name}. geekity settings list names them.`);
+    }
+    return found;
+}
+async function setOrThrow(settings, namespace, changes) {
+    const result = await settings.set(namespace, new Map(Object.entries(changes)), 'cli');
+    if (!result.ok)
+        throw new Error(Object.values(result.problems).join(' '));
+}
+function shown(ref, value) {
+    if (ref.declaration.secret === true) {
+        return value === ref.declaration.default ? '(not set)' : '(set)';
+    }
+    return ref.declaration.type.toText(value);
+}
+async function settingRow(settings, ref) {
+    const resolved = await settings.resolve(ref);
+    let source = sourceLabel(resolved.source);
+    if (overridden(resolved.source) && resolved.stored !== undefined) {
+        source += ` (file: ${shown(ref, resolved.stored)})`;
+    }
+    if (ref.declaration.env === false)
+        source += ', not overridable';
+    return [
+        `${ref.namespace}.${ref.key}`,
+        shown(ref, resolved.value),
+        source,
+        ref.declaration.description,
+    ];
+}
+function table(rows) {
+    const widths = rows[0]?.map((_, column) => Math.max(...rows.map((row) => row[column]?.length ?? 0))) ?? [];
+    return rows
+        .map((row) => `${row.map((cell, column) => (column === row.length - 1 ? cell : cell.padEnd(widths[column] ?? 0))).join('  ')}\n`)
+        .join('');
+}
 function untilFlag(value) {
     if (value === undefined)
         return undefined;
@@ -423,28 +681,52 @@ function forcedLine(forced) {
         ? ' GEEKITY_MAINTENANCE or the maintenance setting keeps it on until the site restarts without it.'
         : '';
 }
-async function stripMetadataCommand({ configPath }) {
-    const config = await loadResolvedConfig(configPath);
-    const results = await stripStoredUploads(path.join(config.contentDir, UPLOAD_DIRECTORY));
-    let stripped = 0;
-    let clean = 0;
-    let unreadable = 0;
-    for (const result of results) {
-        if (result.outcome === 'stripped') {
-            stripped += 1;
-            process.stdout.write(`${result.path}: removed ${result.removed.join(', ')}\n`);
-        }
-        else if (result.outcome === 'clean') {
-            clean += 1;
-        }
-        else {
-            unreadable += 1;
-            process.stderr.write(`${result.path}: ${result.problem} Left as it was.\n`);
+/**
+ * Run one job in this process and return its result, or say on standard
+ * error why there is none. A job of the same name that is already active
+ * stops it before it is queued. A queued job counts only while a server is up
+ * to run it: one a command left queued when it died runs when a server next
+ * starts, and is no reason to refuse while none is.
+ */
+async function runJobHere(config, job, payload, what, prepare) {
+    const cms = createCms(config);
+    let status;
+    try {
+        await prepare?.(cms);
+        const enqueued = await cms.jobs.enqueueUnlessActive(job, payload, {
+            countQueued: await isServing(config.dataDir),
+        });
+        if (!enqueued.queued) {
+            process.stderr.write(`A ${job.name} job is already ${enqueued.active.state}, so this one did not start. ` +
+                `Run the command again once it finishes.\n`);
+            return undefined;
         }
+        status = await cms.jobs.run(enqueued.id);
     }
-    process.stdout.write(`Checked ${count(results.length, 'file')}: ${String(stripped)} stripped, ` +
-        `${String(clean)} already clean, ${String(unreadable)} unreadable\n`);
-    return unreadable === 0 ? 0 : 1;
+    finally {
+        await cms.close();
+    }
+    const result = finishedResult(job, status);
+    if (result === undefined) {
+        const problem = status.state === 'failed' ? status.error : `The job ended ${status.state}.`;
+        process.stderr.write(`The ${what} did not finish: ${problem}\n`);
+    }
+    return result;
+}
+async function stripMetadataCommand({ configPath }) {
+    const config = await loadResolvedConfig(configPath, (loaded) => ({ ...loaded, watch: false }));
+    const report = await runJobHere(config, STRIP_METADATA_JOB, null, 'sweep');
+    if (report === undefined)
+        return 1;
+    for (const file of report.stripped) {
+        process.stdout.write(`${file.path}: removed ${file.removed.join(', ')}\n`);
+    }
+    for (const file of report.unreadable) {
+        process.stderr.write(`${file.path}: ${file.problem} Left as it was.\n`);
+    }
+    process.stdout.write(`Checked ${count(report.checked, 'file')}: ${String(report.stripped.length)} stripped, ` +
+        `${String(report.clean)} already clean, ${String(report.unreadable.length)} unreadable\n`);
+    return report.unreadable.length === 0 ? 0 : 1;
 }
 /**
  * `geekity sync`: bring the index into line with the files once and stop.
@@ -478,43 +760,39 @@ async function syncCommand({ configPath }) {
  * Mastodon keeps the copy of a post it first fetched, so a property added
  * later — the quote policy (TASK-125) is the one that made this a command —
  * reaches a post already out only through an `Update`. This is the resend
- * button on the federation screen, for every post at once. Delivery runs with
- * no queue, so each activity has been posted before the process exits.
+ * button on the federation screen, for every post at once, and it runs the
+ * same resend job (TASK-393). Delivery runs with no queue, so each activity
+ * has been posted before the process exits.
  */
 async function resendCommand({ args, configPath, flags }) {
     const all = flags['all'] === true;
     if (all === args.length > 0) {
         throw new Error('geekity resend needs either --all or the slugs of the posts to resend, and not both.');
     }
-    const cms = createCms(await loadResolvedConfig(configPath, (config) => ({
-        ...config,
+    const config = await loadResolvedConfig(configPath, (loaded) => ({
+        ...loaded,
         watch: false,
-        federation: { ...config.federation, queue: null },
-    })));
-    try {
-        await cms.sync();
-        const slugs = all ? cms.store.listFederated().map((document) => document.slug) : args;
-        let failed = 0;
-        for (const slug of slugs) {
-            const report = await cms.delivery.resend(slug);
-            if (report === undefined) {
-                process.stderr.write(`${slug}: nothing to resend, no announced post has that slug.\n`);
-                failed += 1;
-                continue;
-            }
-            if (report.held) {
-                process.stdout.write(`${slug}: ${report.activityType} held by dev mode, nothing sent\n`);
-                continue;
-            }
-            const reached = report.deliveries.filter((delivery) => delivery.status === 'sent').length;
-            process.stdout.write(`${slug}: ${report.activityType} to ${String(reached)} of ` +
-                `${String(report.deliveries.length)} inboxes\n`);
+        federation: { ...loaded.federation, queue: null },
+    }));
+    const report = await runJobHere(config, RESEND_JOB, { slugs: all ? 'all' : args, webmentions: false }, 'resend', (cms) => cms.sync());
+    if (report === undefined)
+        return 1;
+    let failed = 0;
+    for (const post of report.posts) {
+        const activity = post.resent ? post.activity : null;
+        if (activity === null) {
+            process.stderr.write(`${post.slug}: nothing to resend, no announced post has that slug.\n`);
+            failed += 1;
+        }
+        else if (activity.heldByDevMode) {
+            process.stdout.write(`${post.slug}: ${activity.activityType} held by dev mode, nothing sent\n`);
+        }
+        else {
+            process.stdout.write(`${post.slug}: ${activity.activityType} to ${String(activity.reached)} of ` +
+                `${String(activity.inboxes)} inboxes\n`);
         }
-        return failed === 0 ? 0 : 1;
-    }
-    finally {
-        await cms.close();
     }
+    return failed === 0 ? 0 : 1;
 }
 /**
  * `geekity rebuild`: throw the database away and read it back out of the files.
@@ -544,11 +822,14 @@ async function rebuildCommand({ configPath }) {
             'writing to a file nothing can find.\n');
         return 1;
     }
+    return (await rebuildDatabase(config)) > 0 ? 1 : 0;
+}
+async function rebuildDatabase(config) {
     discardDatabase(config.dataDir);
     const cms = createCms(config);
     try {
         const result = await cms.sync();
-        process.stdout.write(`Rebuilt ${file} from the files.\n` +
+        process.stdout.write(`Rebuilt ${databaseFile(config.dataDir)} from the files.\n` +
             `Scanned ${String(result.scanned)}: ${String(result.created)} created, ` +
             `${String(result.updated)} updated, ${String(result.removed)} removed, ` +
             `${String(result.unchanged)} unchanged, ${String(result.failed)} failed\n` +
@@ -559,14 +840,130 @@ async function rebuildCommand({ configPath }) {
             process.stderr.write(`${String(result.failed)} file${result.failed === 1 ? '' : 's'} could not be parsed and ` +
                 `${result.failed === 1 ? 'was' : 'were'} left out of the index; the warnings above name ` +
                 `${result.failed === 1 ? 'it' : 'them'}.\n`);
-            return 1;
         }
-        return 0;
+        return result.failed;
     }
     finally {
         await cms.close();
     }
 }
+async function importCommand({ args, configPath, flags }) {
+    const [file, ...extra] = args;
+    if (file === undefined) {
+        throw new Error('geekity import needs one archive: geekity import <file>.');
+    }
+    if (extra.length > 0) {
+        throw new Error(`geekity import takes one archive, and no plugin on this site adds "import ${file}".`);
+    }
+    const unsettled = resolveConfig({
+        ...(await loadConfig(process.cwd(), configPath)),
+        watch: false,
+    });
+    const { contentDir, dataDir } = unsettled;
+    if (databaseInUse(dataDir) || (await isServing(dataDir))) {
+        process.stderr.write(`The site is running: ${dataDir} is in use. Stop it and run geekity import again.\n`);
+        return 1;
+    }
+    const archive = path.resolve(file);
+    const targets = { contentDir, dataDir };
+    const settings = createSettings({ config: unsettled });
+    const archived = await readSiteManifest(archive);
+    const { manifest } = archived;
+    const occupied = checkImportTargets(archived, targets, settings).filter((target) => target.state === 'occupied');
+    if (occupied.length > 0 && flags['replace'] !== true) {
+        process.stderr.write(`${occupied.map((target) => target.dir).join(' and ')} already ${occupied.length === 1 ? 'holds' : 'hold'} a site. ` +
+            'Import into empty folders, or give --replace to move what they hold into <dir>/.geekity-before-import-<time> first.\n');
+        return 1;
+    }
+    const staged = await stageSiteImport({ archive, archived, targets, settings });
+    const inEffect = await settleConfig(Object.freeze({ ...unsettled, contentDir: staged.content ?? contentDir }));
+    if (inEffect.baseUrl !== manifest.baseUrl && flags['new-base-url'] !== true) {
+        await discardStaging(staged);
+        process.stderr.write(`The base URL in effect is ${inEffect.baseUrl}, and the archive was exported from ${manifest.baseUrl}. ` +
+            'Actor ids are built from the base URL, so followers would not follow the site to a new address. ' +
+            `Set GEEKITY_BASE_URL, or baseUrl in the config, to ${manifest.baseUrl}, ` +
+            `or give --new-base-url to import it at ${inEffect.baseUrl}.\n`);
+        return 1;
+    }
+    for (const skipped of staged.skipped) {
+        process.stderr.write(`Left out ${skipped.path}: ${skipped.why}.\n`);
+    }
+    for (const aside of await placeSiteImport(staged, { stamp: compactTime(unsettled.now()) })) {
+        process.stdout.write(`Moved what was there into ${aside}.\n`);
+    }
+    process.stdout.write(`Restored ${count(manifest.files.length - staged.skipped.length, 'file')} from ${archive}.\n`);
+    const config = await settleConfig(unsettled);
+    if (flags['dev-mode'] === true) {
+        await setOrThrow(createSettings({ config }), 'dev_mode', { on: true });
+        process.stdout.write('Dev mode is on: nothing the site does is sent until `geekity dev-mode off`.\n');
+    }
+    const failures = await installArchivedPlugins(manifest, {
+        pluginsDir: config.pluginsDir,
+        registry: pluginRegistry(process.env),
+        coreVersion: ownManifest().version,
+    });
+    for (const plugin of manifest.plugins) {
+        if (plugin.source === 'folder' && !failures.some((failed) => failed.name === plugin.name)) {
+            process.stdout.write(`Installed ${plugin.name} ${plugin.version}.\n`);
+        }
+    }
+    await restoreEnabledPlugins(manifest, config.contentDir);
+    await rebuildDatabase(config);
+    await finishSiteImport(targets);
+    process.stdout.write(importNotes(manifest)
+        .map((note) => `${note}\n`)
+        .join(''));
+    for (const failed of failures)
+        process.stderr.write(`${pluginFailureLine(failed)}\n`);
+    return failures.length > 0 ? 1 : 0;
+}
+/**
+ * It runs beside a serving site: no migration runs and no database is opened
+ * but the queue, read-only, to count what waits in it.
+ */
+async function exportCommand({ configPath, flags }) {
+    const config = await loadResolvedConfig(configPath, (loaded) => ({ ...loaded, watch: false }));
+    const settings = createSettings({ config });
+    const plugins = await loadSitePlugins(config, settings);
+    if (flags['list'] === true) {
+        const declarations = siteDataFiles({ dataDir: config.dataDir, settings, plugins });
+        process.stdout.write(table([
+            ...declarations.map((each) => [`data/${each.pattern}`, each.dataClass.kind, each.lost]),
+            ['content/**', 'kept', 'The site: its documents, uploads and _data.'],
+            ...CONTENT_SCRATCH_FILES.map((each) => [
+                `content/${each.pattern}`,
+                each.dataClass.kind,
+                each.lost,
+            ]),
+        ]));
+        return 0;
+    }
+    const plan = await planSiteExport({ config, settings, plugins }, {
+        withCredentials: flags['with-credentials'] === true,
+        withContent: flags['without-content'] !== true,
+    });
+    const { deliveries } = plan.site.pending;
+    process.stdout.write(`${count(deliveries, 'delivery is', 'deliveries are')} waiting in data/queue.sqlite. ` +
+        'They are not exported: before a move, wait until none are.\n' +
+        'The archive holds actor keys, password hashes and personal data. ' +
+        'Store it as carefully as data/.\n');
+    const now = config.now();
+    const out = path.resolve(text(flags, 'out') ?? exportFileName(config.baseUrl, now));
+    const manifest = await writeSiteExport(plan, { out, now });
+    for (const file of manifest.undeclared) {
+        process.stderr.write(`Left out ${file}: no declaration says what it is.\n`);
+    }
+    for (const entry of manifest.notCarried) {
+        process.stderr.write(`Left out ${entry.path}: it is ${entry.why}, and an export holds only regular files.\n`);
+    }
+    if (manifest.credentialsLeftOut.length > 0) {
+        process.stdout.write(`Credentials left out: ${manifest.credentialsLeftOut.join(', ')}. ` +
+            '--with-credentials includes them.\n');
+    }
+    const bytes = manifest.files.reduce((total, file) => total + file.size, 0);
+    process.stdout.write(`Wrote ${out}: ${count(manifest.files.length, 'file')}, ${count(bytes, 'byte')}.\n`);
+    return 0;
+}
 /** "1 follower", "2 followers". The plural is the singular plus s unless told. */
 /** How many comments the files hold, whatever a moderator has done with them. */
 function totalComments(admin) {
@@ -679,7 +1076,7 @@ async function serveWorker(configPath) {
             supervision: worker.supervision,
         });
         const { port } = await cms.serve();
-        if (devModeOn(cms.config)) {
+        if (await cms.settings.get(DEV_MODE.on)) {
             process.stdout.write('Dev mode is on: ActivityPub, webmentions, feed pings, IndexNow and email are held ' +
                 'and recorded in data/dev-mode.jsonl. `geekity dev-mode off` takes the site live.\n');
         }
@@ -876,17 +1273,26 @@ function configFlag(argv) {
     }
     return undefined;
 }
+async function loadSitePlugins(config, settings) {
+    const folderPlugins = await importPluginFolders(scanPluginFolders(config.pluginsDir));
+    return sitePluginRegistry(config, folderPlugins, settings);
+}
 /**
  * Every command the site's available plugins add, from its config and its
  * plugins folder, longest words first.
  */
 async function pluginCommands(config) {
-    const folderPlugins = await importPluginFolders(scanPluginFolders(config.pluginsDir));
-    return sitePluginRegistry(config, folderPlugins)
-        .plugins.filter((entry) => entry.problem === undefined)
+    return (await loadSitePlugins(config, createSettings({ config }))).plugins
+        .filter((entry) => entry.problem === undefined)
         .flatMap((entry) => entry.commands.map((command) => ({ plugin: entry.plugin.name, command })))
         .sort((a, b) => b.command.words.length - a.command.words.length);
 }
+async function pluginExtends(first, words, configPath) {
+    if (COMMANDS[first].sharedWithPlugins !== true || words.length < 2)
+        return false;
+    const found = await pluginCommands(await loadResolvedConfig(configPath));
+    return found.some(({ command }) => command.words.every((word, index) => words[index] === word));
+}
 /**
  * Run a command a plugin added (decision-33). It needs no enabling: a
  * migration command runs before the plugin it prepares for is turned on.
@@ -896,12 +1302,20 @@ async function pluginCommands(config) {
  * version that kept its accounts in SQLite is migrated first. The comments
  * are migrated as a boot would migrate them for the same reason: a command
  * writing comments before any server has would otherwise meet ids the site
- * refuses to store.
+ * refuses to store. Plugin settings still in `site.json` move to
+ * `data/plugins/<name>/` first, so the command reads what a boot would.
  */
 async function pluginCommand(argv) {
     const configPath = configFlag(argv);
     const config = await loadResolvedConfig(configPath);
     const words = leadingWords(argv);
+    migratePluginSettings({
+        contentDir: config.contentDir,
+        dataDir: config.dataDir,
+        log: (line) => {
+            console.log(line);
+        },
+    });
     const found = (await pluginCommands(config)).find(({ command }) => command.words.every((word, index) => words[index] === word));
     if (found === undefined) {
         throw new Error(`Unknown command "${words[0] ?? ''}". Run geekity --help to see what is available.`);