@loopress/cli 0.29.0 → 0.31.0

package/dist/commands/acf/push.js

@@ -26,7 +26,8 @@ export default class Push extends PushCommand {
         this.log(`Pushing ACF configuration to ${url}`);
         this.log(`ACF path: ${path}`);
         const provider = getResourceStateProvider('acf');
-        const beforeState = await this.captureBeforePushState(provider, path);
+        // `--type` leaves the other types untouched: only the pushed ones count as overwritten.
+        const beforeState = await this.captureBeforePushState(provider, path, (id) => types.some((type) => id.startsWith(`${type}/`)));
         for (const type of types) {
             await this.pushType(type, path);
         }

package/dist/commands/composer/push.d.ts

@@ -17,5 +17,6 @@ export default class ComposerPush extends PushCommand {
     };
     run(): Promise<PushResult>;
     private reportLockDrift;
+    private wpackagistToRemove;
 }
 export {};

package/dist/commands/composer/push.js

@@ -2,6 +2,7 @@ import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { confirmUninstall } from '../../lib/interactive.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isLocalEnvironment, isTimeoutError } from '../../lib/wp-client.js';
 import { requireToInstall, toIntent } from '../../utils/composer.js';
@@ -37,8 +38,15 @@ export default class ComposerPush extends PushCommand {
         this.log(`Pushing composer.json (${packageCount} ${packageCount === 1 ? 'package' : 'packages'}) to ${url}`);
         if (lock)
             this.log('  + composer.lock sent for drift comparison (the server resolves versions from composer.json)');
+        // The server renders composer.json from this intent alone, so a WordPress.org plugin or theme
+        // the site has and this file lacks gets uninstalled, active or not: say so before it happens.
+        const toRemove = await this.wpackagistToRemove(require);
+        if (toRemove.length > 0)
+            this.log(`Would uninstall from the site, absent from composer.json: ${toRemove.join(', ')}`);
         if (this.dryRun)
             return { hasLock, lockDrift: [], packageCount, status: 'dry-run' };
+        if (!(await confirmUninstall(toRemove, this.yes)))
+            this.error('Aborted.');
         this.log('Running Composer on the server, this can take a few minutes...');
         let response;
         try {
@@ -74,4 +82,9 @@ export default class ComposerPush extends PushCommand {
         }
         this.log('Run `lps composer pull` to update your local composer.json and composer.lock.');
     }
+    async wpackagistToRemove(require) {
+        const { composerJson } = await this.wp.get('loopress/v1/composer/json');
+        const current = JSON.parse(composerJson).require ?? {};
+        return Object.keys(current).filter((name) => name.startsWith('wpackagist-') && !Object.hasOwn(require, name));
+    }
 }

package/dist/commands/content/copy.d.ts

@@ -0,0 +1,28 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { WpClient } from '../../lib/wp-client.js';
+type ContentCopyResult = {
+    from: string;
+    posts: number;
+    status: 'copied' | 'dry-run';
+    terms: number;
+};
+export default class Copy extends LoopressCommand {
+    static args: {
+        from: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static baseFlags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<ContentCopyResult>;
+    protected sourceWp(from: string): WpClient;
+    private confirmReplace;
+    private copy;
+}
+export {};

package/dist/commands/content/copy.js

@@ -0,0 +1,97 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { configManager } from '../../config/project-config.manager.js';
+import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { isLocalEnvironment, LOCAL_ENVIRONMENT_NAME, WpClient } from '../../lib/wp-client.js';
+import { pluralize } from '../../utils/pluralize.js';
+const BATCH_SIZE = 100;
+// Code goes up, content comes down: the content of <from> replaces the local site's, IDs
+// unchanged, never the reverse and never into the repo. Not a `pull`: nothing is written to
+// local files. The target is always "local", so there is no --env (this.wp is the local site),
+// <from> names the source like `lps promote`. Terms go first, so the post batches can attach
+// their term relationships. The plugin refuses the import on any site whose environment type is
+// not "local", whatever this command is pointed at.
+export default class Copy extends LoopressCommand {
+    static args = {
+        from: Args.string({ description: 'Environment to copy the content from', required: true }),
+    };
+    // Hidden, not removed: the type of LoopressCommand.baseFlags requires it. Any value other than
+    // "local" is refused in run().
+    static baseFlags = {
+        env: Flags.string({ hidden: true }),
+    };
+    static description = 'Replace the local site\'s content (posts, pages, public custom post types, terms) with the content of <from>, then push the project to the local site so tracked configuration wins. Media stay served by <from>, users, comments and orders are never copied.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps content copy production', '$ lps content copy staging --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Copy);
+        const { from } = args;
+        if (!isLocalEnvironment(this.siteConfig.name)) {
+            this.error(`Content is only ever copied into the "${LOCAL_ENVIRONMENT_NAME}" environment. Run \`lps project config\` to add it if the project has none.`);
+        }
+        if (isLocalEnvironment(from)) {
+            this.error(`<from> must be another environment than "${LOCAL_ENVIRONMENT_NAME}", e.g. \`lps content copy production\`.`);
+        }
+        const source = this.sourceWp(from);
+        if (!this.dryRun)
+            await this.confirmReplace(from);
+        const info = await source.get('loopress/v1/content');
+        if (!this.dryRun) {
+            await this.wp.post('loopress/v1/content/reset', { home: info.home, uploadsUrl: info.uploadsUrl });
+        }
+        this.log(`\n→ Copying terms from ${from}...`);
+        const terms = await this.copy('terms', source);
+        this.log(`→ Copying posts from ${from}...`);
+        const posts = await this.copy('posts', source);
+        const summary = `${pluralize(posts, 'post')} and ${pluralize(terms, 'term')}`;
+        if (this.dryRun) {
+            this.log(`\n[dry-run] Would replace the local content with ${summary} from ${from}, then push the project to ${LOCAL_ENVIRONMENT_NAME}.`);
+            return { from, posts, status: 'dry-run', terms };
+        }
+        this.log(`\n→ Pushing the project to ${LOCAL_ENVIRONMENT_NAME}...`);
+        await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', ['--env', LOCAL_ENVIRONMENT_NAME, '--yes']));
+        this.log(`\nCopied ${summary} from ${from}.`);
+        return { from, posts, status: 'copied', terms };
+    }
+    // Overridable seam for tests, like `wpClient` on LoopressCommand.
+    sourceWp(from) {
+        const project = configManager.getProject(this.projectId);
+        const env = project?.environments[from];
+        if (!env) {
+            this.error(`Environment "${from}" not found. Available: ${Object.keys(project?.environments ?? {}).join(', ')}`);
+        }
+        if (!env.token)
+            this.error(`No credentials configured for ${env.url}. Run \`lps project config\` to add them.`);
+        return new WpClient(env.url, env.token, env.name);
+    }
+    async confirmReplace(from) {
+        if (this.yes)
+            return;
+        const message = `This deletes the posts, pages and terms of the "${LOCAL_ENVIRONMENT_NAME}" site and replaces them with ${from}'s.`;
+        if (!isInteractive())
+            this.error(`${message} Pass --yes to confirm.`);
+        const isProceed = await confirm({ default: true, message: `${message} Continue?` });
+        if (!isProceed)
+            this.error('Aborted.');
+    }
+    // Pages through the source, each page posted to the local site as is.
+    async copy(kind, source) {
+        let count = 0;
+        let after = 0;
+        while (after !== null) {
+            const page = await source.get(`loopress/v1/content/${kind}?after=${after}&limit=${BATCH_SIZE}`);
+            const { next, ...rows } = page;
+            count += rows[kind].length;
+            if (!this.dryRun)
+                await this.wp.post(`loopress/v1/content/${kind}`, rows);
+            after = next;
+        }
+        return count;
+    }
+}

package/dist/commands/cpt/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('cpt', {
+    description: 'Show what differs in custom post types between your local cpt/ files and a WordPress environment, or between two environments',
+    pathNoun: 'cpt directory',
+});

package/dist/commands/cpt/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredListCommand>;
+export default _default;

package/dist/commands/cpt/list.js

@@ -0,0 +1,4 @@
+import { declaredListCommand } from '../../lib/declared-type-command.js';
+import { CPT_SPEC } from '../../utils/declared-type-format.js';
+export default declaredListCommand(CPT_SPEC, 'List the post types registered on WordPress and where each comes from (Loopress, WordPress, ACF, CPT UI, a theme or plugin). ' +
+    'Only Loopress ones are pulled and pushed.', (count) => `${count} published`);

package/dist/commands/cpt/pull.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/cpt/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { CPT_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(CPT_SPEC, 'Pull the custom post types Loopress manages on WordPress into cpt/<slug>.json files. ' +
+    'Post types registered by a theme or another plugin are never pulled, see `lps cpt list`.');

package/dist/commands/cpt/push.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/cpt/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { CPT_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(CPT_SPEC, 'Push local custom post types (cpt/<slug>.json, register_post_type() arguments) to WordPress. ' +
+    'Create or update only, never deletes a post type: use `lps cpt rm` for that.');

package/dist/commands/cpt/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/cpt/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { CPT_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(CPT_SPEC, 'Stop registering a Loopress custom post type on WordPress. Its posts are kept in the database, hidden until the post type is pushed again.', "Its posts are kept in the database, hidden until it's pushed again.");

package/dist/commands/cpt/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('cpt', {
+    description: 'Restore custom post types to a snapshot taken automatically before an earlier `lps cpt push`',
+    pathNoun: 'cpt directory',
+});

package/dist/commands/dev.js

@@ -48,18 +48,28 @@ export default class Dev extends Command {
     }
     // Sequential on purpose (see notes technique: parallelizing push is out of scope). A failed
     // push is logged and swallowed here, never thrown, so one bad batch can't take the watcher down.
+    // Types sharing a command run it once: templates, parts, css and blocks all rewrite the whole
+    // child theme through `theme:template:push`.
     async pushBatch(changesByType, targets) {
+        const byCommand = new Map();
         for (const [type, paths] of changesByType) {
             const target = targets.find((t) => t.type === type);
             if (!target)
                 continue;
-            this.log(`\n→ ${type} changed (${paths.map((path) => basename(path)).join(', ')}), pushing to local...`);
+            const batch = byCommand.get(target.commandId) ?? { paths: [], types: [] };
+            batch.types.push(type);
+            batch.paths.push(...paths);
+            byCommand.set(target.commandId, batch);
+        }
+        for (const [commandId, { paths, types }] of byCommand) {
+            const label = types.join(', ');
+            this.log(`\n→ ${label} changed (${paths.map((path) => basename(path)).join(', ')}), pushing to local...`);
             try {
-                await this.config.runCommand(target.commandId, ['--env', 'local']);
-                this.log(`✓ ${type} synced`);
+                await this.config.runCommand(commandId, ['--env', 'local']);
+                this.log(`✓ ${label} synced`);
             }
             catch (error) {
-                this.log(`✗ ${type} failed: ${error.message}`);
+                this.log(`✗ ${label} failed: ${error.message}`);
             }
         }
     }

package/dist/commands/diff.js

@@ -7,7 +7,7 @@ const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resour
 export default class Diff extends DiffCommand {
     static description = [
         'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
-        'Covers snippets, forms, ACF, API routes, Hooks, templates, template parts, pages, SEO, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Covers snippets, forms, ACF, API routes, Hooks, templates, template parts, pages, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
         'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
     ].join(' ');
     static enableJsonFlag = true;

package/dist/commands/doctor.d.ts

@@ -19,6 +19,8 @@ export default class Doctor extends LoopressCommand {
     private readonly checks;
     run(): Promise<DoctorResult>;
     private check;
+    private checkHookErrors;
+    private checkLeftoverTempAdmins;
     private out;
     private reportPluginVersion;
 }

package/dist/commands/doctor.js

@@ -1,6 +1,8 @@
 import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
-import { isNotFoundError } from '../lib/wp-client.js';
+import { formatRuntimeError, HOOK_FILES_RESOURCE } from '../lib/php-files-command.js';
+import { findTempAdmins } from '../lib/temp-admin.js';
+import { isForbiddenError, isNotFoundError } from '../lib/wp-client.js';
 import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
 import { pluralize } from '../utils/pluralize.js';
 export default class Doctor extends LoopressCommand {
@@ -32,7 +34,12 @@ export default class Doctor extends LoopressCommand {
                 await this.check('Loopress plugin installed (loopress/v1 endpoints)', async () => this.wp.get('loopress/v1'));
                 // wp/v2/users/me is WordPress core and requires authentication, so it validates the
                 // application password without depending on any Loopress feature.
-                await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me'));
+                const isAuthenticated = await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me'));
+                // Skipped when the credentials were just rejected: it would only repeat that same 401.
+                if (isAuthenticated) {
+                    await this.checkLeftoverTempAdmins();
+                    await this.checkHookErrors();
+                }
                 pluginVersion = await this.reportPluginVersion();
             }
             else {
@@ -72,6 +79,54 @@ export default class Doctor extends LoopressCommand {
             return false;
         }
     }
+    // A hook that fails to load or throws while running doesn't break the site, it just quietly
+    // does nothing, and its only trace is an error_log nobody reads on managed hosting.
+    async checkHookErrors() {
+        let lookup;
+        try {
+            lookup = { files: await this.wp.get(HOOK_FILES_RESOURCE.endpoint) };
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return; // Loopress Light has no hooks
+            lookup = { error };
+        }
+        await this.check('Hooks load and run without errors', async () => {
+            if ('error' in lookup)
+                throw lookup.error;
+            const files = Array.isArray(lookup.files) ? lookup.files : [];
+            const problems = files.flatMap((file) => [
+                ...(file.error ? [`hooks/${file.filename}.php: ${file.error}`] : []),
+                ...(file.runtimeError ? [`hooks/${file.filename}.php: ${formatRuntimeError(file.runtimeError)}`] : []),
+            ]);
+            if (problems.length > 0)
+                throw new Error(problems.join('\n  '));
+        });
+    }
+    // Report only, never deletes: a doctor run shouldn't change the site. A leftover is a live
+    // administrator with a password nobody holds, so it fails the run. Credentials without
+    // `list_users` can't look, which is informational, not a failure: nothing was found wrong.
+    async checkLeftoverTempAdmins() {
+        let lookup;
+        try {
+            lookup = { leftovers: await findTempAdmins(this.wp) };
+        }
+        catch (error) {
+            lookup = { error };
+        }
+        if ('error' in lookup && isForbiddenError(lookup.error)) {
+            this.out('- Leftover temporary admin accounts: not checked, these credentials cannot list users.');
+            return;
+        }
+        await this.check('No leftover temporary admin accounts', async () => {
+            if ('error' in lookup)
+                throw lookup.error;
+            if (lookup.leftovers.length > 0) {
+                const names = lookup.leftovers.map((admin) => admin.username).join(', ');
+                throw new Error(`Found ${names}, left by an interrupted Loopress Full install. Re-run \`lps project config\` to remove them, or delete them in wp-admin > Users.`);
+            }
+        });
+    }
     out(message) {
         if (!this.jsonEnabled())
             this.log(message);

package/dist/commands/form/push.js

@@ -1,5 +1,5 @@
 import { Args, Flags } from '@oclif/core';
-import { readFile, rename } from 'node:fs/promises';
+import { readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
@@ -120,6 +120,9 @@ export default class Push extends PushCommand {
                 putEndpoint: formEndpoint,
             });
             const canonicalId = created ? getFormId(body) : id;
+            // The id is read from the file, not its name: without it the next push creates the form again.
+            if (created && canonicalId !== null)
+                await writeFile(filePath, JSON.stringify({ ...data, id: canonicalId }, null, 2) + '\n');
             if (canonicalId !== null)
                 await this.ensureCanonicalFilename(filePath, canonicalId, title);
             if (task)

package/dist/commands/meta/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/meta/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('meta', {
+    description: 'Show what differs in post meta keys between your local meta/ files and a WordPress environment, or between two environments',
+    pathNoun: 'meta directory',
+});

package/dist/commands/meta/list.d.ts

@@ -0,0 +1,19 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RegisteredMetaKey = {
+    acf: boolean;
+    conflict: boolean;
+    key: string;
+    managed: boolean;
+    postType: string;
+    showInRest: boolean;
+    single: boolean;
+    source: 'loopress' | 'other';
+    type: string;
+};
+export default class MetaList extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<RegisteredMetaKey[]>;
+}
+export {};

package/dist/commands/meta/list.js

@@ -0,0 +1,21 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { META_SPEC } from '../../utils/declared-type-format.js';
+export default class MetaList extends LoopressCommand {
+    static description = 'List the meta keys registered for each post type on WordPress (with register_post_meta()), and whether Loopress declares them. ' +
+        'Only Loopress ones are pulled and pushed.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps meta list'];
+    async run() {
+        const keys = await this.wp.get(META_SPEC.registeredEndpoint);
+        for (const meta of keys) {
+            const source = meta.source === 'loopress' ? 'Loopress' : 'theme or plugin';
+            const rest = meta.showInRest ? ', in REST' : '';
+            const acf = meta.acf ? ', same name as an ACF field' : '';
+            this.log(`${meta.postType}.${meta.key} (${meta.type}): ${source}${rest}${acf}`);
+            if (meta.conflict) {
+                this.warn(`${meta.postType}.${meta.key}: declared in meta/ but already registered by a theme or plugin, the Loopress version is skipped`);
+            }
+        }
+        return keys;
+    }
+}

package/dist/commands/meta/pull.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/meta/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { META_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(META_SPEC, 'Pull the post meta keys Loopress manages on WordPress into meta/<post-type>.json files, never their values. ' +
+    'Keys registered by a theme or another plugin are never pulled, see `lps meta list`.');

package/dist/commands/meta/push.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/meta/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { META_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(META_SPEC, 'Push local post meta keys (meta/<post-type>.json, each key mapped to its register_post_meta() arguments) to WordPress. ' +
+    'Create or update only, never deletes (use `lps meta rm`), never touches meta values.');

package/dist/commands/meta/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/meta/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { META_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(META_SPEC, 'Stop registering the Loopress meta keys of one post type (its meta/<post-type>.json file) on WordPress. Their values are kept in the database.', "Their values are kept in the database, hidden until it's pushed again.");

package/dist/commands/meta/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/meta/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('meta', {
+    description: 'Restore post meta keys to a snapshot taken automatically before an earlier `lps meta push`',
+    pathNoun: 'meta directory',
+});

package/dist/commands/option/list.js

@@ -1,6 +1,7 @@
 import { Flags, ux } from '@oclif/core';
 import ttyTable from 'tty-table';
 import { LoopressCommand } from '../../lib/base.js';
+import { withSpinner } from '../../lib/spinner.js';
 import { OPTIONS_ENDPOINT } from '../../utils/option-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 // Same green/yellow pairing drives both SOURCE? and PLUGIN, so a row's whole "where did this come
@@ -127,14 +128,7 @@ export default class List extends LoopressCommand {
         // Every call scans active plugins' own PHP source for names the naming guess missed (not
         // opt-in, roughly 1-3s on a real site once vendor/tests/languages are pruned from the scan;
         // see OptionsService::listOptionNames() server-side), hence the spinner unconditionally.
-        ux.action.start('Fetching and verifying options');
-        let options;
-        try {
-            options = await this.wp.get(OPTIONS_ENDPOINT);
-        }
-        finally {
-            ux.action.stop();
-        }
+        let options = await withSpinner('Fetching and verifying options', async () => this.wp.get(OPTIONS_ENDPOINT));
         if (flags['no-core'])
             options = options.filter((option) => !option.core);
         if (options.length === 0) {

package/dist/commands/option/push.js

@@ -23,8 +23,6 @@ export default class Push extends PushCommand {
         const { url } = this.siteConfig;
         this.log(`Pushing tracked options to ${url}`);
         this.log(`Options path: ${dir}`);
-        const provider = getResourceStateProvider('option');
-        const beforeState = await this.captureBeforePushState(provider, dir);
         const tracked = await loadFiles(dir, {
             extension: '.json',
             onSkip: (message) => {
@@ -33,6 +31,10 @@ export default class Push extends PushCommand {
             parse: parseLocalOption,
         });
         const { skipped, writable } = partitionByReadonly(tracked);
+        const provider = getResourceStateProvider('option');
+        // Readonly options are never written, so a site-side change to one is no reason to stop.
+        const writableNames = new Set(writable.map((option) => option.name));
+        const beforeState = await this.captureBeforePushState(provider, dir, (name) => writableNames.has(name));
         if (skipped.length > 0) {
             this.log(`Skipping ${pluralize(skipped.length, 'readonly option')}: ${skipped.map((option) => option.name).join(', ')}`);
         }

package/dist/commands/page/push.js

@@ -29,13 +29,14 @@ export default class Push extends PushCommand {
             this.error(`No page "${args.slug}" in ${path} (expected ${args.slug}.html).`);
         }
         this.log(`Found ${pluralize(selected.length, 'page')} to push`);
-        if (this.dryRun)
-            await this.previewRemote(getResourceStateProvider('page'), path);
+        const provider = getResourceStateProvider('page');
+        const beforeState = await this.captureBeforePushState(provider, path, args.slug === undefined ? undefined : (id) => id === args.slug);
         const pushed = [];
         await this.runPushTasks(selected, (page) => page.slug, async (page, task) => {
             await this.pushPage(page, task);
             pushed.push(page.slug);
         });
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'page')} failed to push.`);
         }

package/dist/commands/pattern/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/pattern/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('pattern', {
+    description: 'Show what differs in block patterns between your local patterns/ files and a WordPress environment, or between two environments',
+    pathNoun: 'patterns directory',
+});

package/dist/commands/pattern/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredListCommand>;
+export default _default;

package/dist/commands/pattern/list.js

@@ -0,0 +1,3 @@
+import { declaredListCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredListCommand(PATTERN_SPEC, 'List the block patterns registered on WordPress by Loopress, the theme and plugins (not WordPress core). Only Loopress ones are pulled and pushed.', () => '');

package/dist/commands/pattern/pull.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/pattern/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(PATTERN_SPEC, 'Pull the block patterns Loopress manages on WordPress into patterns/<slug>.html files. ' +
+    'Patterns registered by the theme or a plugin are never pulled, see `lps pattern list`.');

package/dist/commands/pattern/push.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/pattern/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(PATTERN_SPEC, 'Push local block patterns (patterns/<slug>.html, block markup under a title/categories header) to WordPress, ' +
+    'registered as loopress/<slug>. Create or update only, never deletes a pattern (use `lps pattern rm`).');

package/dist/commands/pattern/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/pattern/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(PATTERN_SPEC, 'Stop registering a Loopress block pattern on WordPress. A wp:pattern reference to it renders nothing, copies already inserted in posts stay.', 'A wp:pattern reference to it renders nothing until it is pushed again, copies already inserted in posts stay.');

package/dist/commands/pattern/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/pattern/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('pattern', {
+    description: 'Restore block patterns to a snapshot taken automatically before an earlier `lps pattern push`',
+    pathNoun: 'patterns directory',
+});