@loopress/cli 0.24.1 → 0.25.0

package/dist/commands/menu/push.js

@@ -0,0 +1,120 @@
+import { Args } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { PushCommand } from '../../lib/push-command.js';
+import { readdirTolerant } from '../../lib/readdir-tolerant.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT, menuEndpoint } from '../../utils/menu-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+// A menu literally slugged "menu-locations" would still collide, but that's far less likely
+// than the plain "locations" this used to be (WordPress's own menu-locations feature).
+const LOCATIONS_FILENAME = 'menu-locations.json';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to menus directory (overrides project config)' }),
+    };
+    static description = 'Push local nav menus and the active theme menu locations to WordPress. Each menu\'s post_type/taxonomy items are resolved by slug on the target environment, never by a raw id; an item whose target does not exist there fails the whole menu rather than guessing.';
+    static examples = ['$ lps menu push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveMenuPath(args.path);
+        this.log(`Pushing nav menus to ${url}`);
+        this.log(`Menus path: ${path}`);
+        const provider = getResourceStateProvider('menu');
+        const beforeState = await this.captureBeforePushState(provider, path);
+        await this.pushMenus(path);
+        await this.pushLocations(path);
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'menu')} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All nav menus pushed.');
+    }
+    async currentRevision(slug) {
+        try {
+            const current = await this.wp.get(menuEndpoint(slug));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async pushLocations(basePath) {
+        const file = join(basePath, LOCATIONS_FILENAME);
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${file}`);
+            return;
+        }
+        try {
+            await this.wp.put(MENU_LOCATIONS_ENDPOINT, JSON.parse(raw));
+            this.log(`Pushed: ${file}`);
+        }
+        catch (error) {
+            this.failedCount++;
+            this.warn(`Failed to push ${file}: ${error.message}`);
+        }
+    }
+    async pushMenuFile(filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const parsed = JSON.parse(await readFile(filePath, 'utf8'));
+            if (typeof parsed !== 'object' || parsed === null)
+                throw new Error('not a JSON object');
+            const record = parsed;
+            const slug = getMenuSlug(record);
+            if (slug === null)
+                throw new Error('missing or invalid "slug"');
+            const name = typeof record.name === 'string' ? record.name : '';
+            const items = record.items ?? [];
+            if (!Array.isArray(items))
+                throw new Error('"items" must be an array');
+            // Read the menu's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the menu
+            // in between, instead of this push silently overwriting it (#234). No revision to condition
+            // on for a menu that doesn't exist remotely yet (a first push, an upsert create): falls back
+            // to today's unconditional write, same as before this existed.
+            const expectedRevision = await this.currentRevision(slug);
+            const body = { items, name, slug };
+            if (expectedRevision !== undefined)
+                body.expectedRevision = expectedRevision;
+            const result = await this.wp.post(MENU_ENDPOINT, body);
+            if (task) {
+                task.output = result.warnings.length > 0 ? `Pushed: ${slug} (warning: ${result.warnings.join('; ')})` : `Pushed: ${slug}`;
+            }
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${filePath}: ${error.message}`, error, task);
+        }
+    }
+    async pushMenus(basePath) {
+        const files = (await readdirTolerant(basePath)).filter((file) => extname(file) === '.json' && file !== LOCATIONS_FILENAME);
+        if (files.length === 0)
+            return;
+        this.log(`Found ${pluralize(files.length, 'menu')} to push`);
+        await this.runPushTasks(files, (file) => file, async (file, task) => this.pushMenuFile(join(basePath, file), task));
+    }
+}

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

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

package/dist/commands/menu/rollback.js

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

package/dist/commands/option/add.js

@@ -33,7 +33,7 @@ export default class Add extends LoopressCommand {
             }
             throw error;
         }
-        const local = { ...remote, readonly: defaultReadonlyFor(name) };
+        const local = { autoload: remote.autoload, name: remote.name, readonly: defaultReadonlyFor(name), value: remote.value };
         const file = join(dir, optionFileName(name));
         if (this.dryRun) {
             this.log(`[dry-run] Would track "${name}" at ${file}`);

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

@@ -16,6 +16,7 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private currentRevision;
     private pushOption;
 }
 export {};

package/dist/commands/option/push.js

@@ -1,6 +1,8 @@
 import { Args } from '@oclif/core';
 import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
 import { optionEndpoint, parseLocalOption, partitionByReadonly } from '../../utils/option-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
@@ -21,6 +23,8 @@ 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) => {
@@ -38,6 +42,7 @@ export default class Push extends PushCommand {
             await this.pushOption(option, task);
             pushed.push(option.name);
         });
+        await this.writeAfterPushSnapshot(provider, dir, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'option')} failed to push.`);
         }
@@ -48,6 +53,17 @@ export default class Push extends PushCommand {
         this.log('All options pushed.');
         return { pushed, skipped: skippedNames, status: 'success' };
     }
+    async currentRevision(name) {
+        try {
+            const current = await this.wp.get(optionEndpoint(name));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     async pushOption(option, task) {
         if (this.dryRun) {
             if (task)
@@ -55,7 +71,16 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.put(optionEndpoint(option.name), { autoload: option.autoload, value: option.value });
+            // Read the option's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // option in between, instead of this push silently overwriting it (#234). No revision to
+            // condition on for an option that doesn't exist remotely yet (a first push, an upsert
+            // create): falls back to today's unconditional write, same as before this existed.
+            const expectedRevision = await this.currentRevision(option.name);
+            const body = { autoload: option.autoload, value: option.value };
+            if (expectedRevision !== undefined)
+                body.expectedRevision = expectedRevision;
+            await this.wp.put(optionEndpoint(option.name), body);
             if (task)
                 task.output = `Pushed: ${option.name}`;
         }

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

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

package/dist/commands/option/rollback.js

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

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

@@ -22,6 +22,7 @@ export default class Push extends PushCommand {
     private deactivate;
     private deactivateEndangered;
     private fetchInstanceLock;
+    private filesForNewlyInstalled;
     private guardForce;
     private result;
     private sync;

package/dist/commands/plugin/push.js

@@ -70,6 +70,7 @@ export default class Push extends PushCommand {
             await this.activate(deactivated.filter((p) => !diff.toRemove.includes(p.slug)));
             throw error;
         }
+        toReactivate.push(...(await this.filesForNewlyInstalled(diff.toInstall)));
         if (toPrune.length > 0) {
             await this.deactivate(installed.filter((p) => toPrune.includes(p.slug)));
         }
@@ -126,6 +127,19 @@ export default class Push extends PushCommand {
             throw error;
         }
     }
+    // toInstall entries carry no `file`: the plugin didn't exist on the site at diff time, so its
+    // WordPress core plugin id (folder/main-file.php) is only knowable after sync() has actually
+    // installed it. Refetch to get it, then activate like everything else.
+    async filesForNewlyInstalled(toInstall) {
+        if (toInstall.length === 0)
+            return [];
+        const installedAfterSync = parseInstalledPlugins(await this.wp.get('wp/v2/plugins'));
+        const fileBySlug = new Map(installedAfterSync.map((p) => [p.slug, p.file]));
+        return toInstall.flatMap(({ slug }) => {
+            const file = fileBySlug.get(slug);
+            return file ? [{ file, slug }] : [];
+        });
+    }
     guardForce(diff, force) {
         if (force)
             return;

package/dist/commands/promote.d.ts

@@ -1,18 +1,25 @@
 import { Command } from '@oclif/core';
+type PromoteResult = {
+    from: string;
+    status: 'dry-run' | 'promoted';
+    to: string;
+};
 export default class Promote extends Command {
     static args: {
         from: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         to: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     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<void>;
+    run(): Promise<PromoteResult>;
     private confirmPromotion;
     private delegateArgv;
     private requireEnvironment;
     private resolveProject;
 }
+export {};

package/dist/commands/promote.js

@@ -10,6 +10,7 @@ export default class Promote extends Command {
         to: Args.string({ description: 'Environment to copy the configuration to', required: true }),
     };
     static description = 'Copy every tracked resource from one environment to another by pulling from <from> then pushing to <to>. Local tracked files are overwritten with <from> in the process.';
+    static enableJsonFlag = true;
     static examples = ['$ lps promote staging production', '$ lps promote production staging --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -38,6 +39,7 @@ export default class Promote extends Command {
         this.log(`\n=== Pushing to ${to.name} (${to.url}) ===`);
         await this.config.runCommand('push', this.delegateArgv(to.name, dryRun));
         this.log(dryRun ? `\n[dry-run] ${from.name} would be promoted to ${to.name}.` : `\n${from.name} promoted to ${to.name}.`);
+        return { from: from.name, status: dryRun ? 'dry-run' : 'promoted', to: to.name };
     }
     // Deliberately not `guardProductionPush`: promote overwrites local tracked files for every
     // target, not just production, so it needs its own confirmation regardless of the name. That

package/dist/commands/pull.d.ts

@@ -1,12 +1,22 @@
 import { LoopressCommand } from '../lib/base.js';
+type PullTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pulled';
+};
+type PullResult = {
+    results: PullTargetResult[];
+};
 export default class Pull extends LoopressCommand {
     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>;
     };
     private failedCount;
-    run(): Promise<void>;
+    run(): Promise<PullResult>;
     private buildArgv;
 }
+export {};

package/dist/commands/pull.js

@@ -11,11 +11,13 @@ const PULL_TARGETS = [
     { commandId: 'hook:pull', label: 'hooks', supportsYes: true },
     { commandId: 'form:pull', label: 'forms', supportsYes: true },
     { commandId: 'seo:pull', label: 'SEO', supportsYes: true },
+    { commandId: 'menu:pull', label: 'menus', supportsYes: true },
     { commandId: 'option:pull', label: 'options', supportsYes: true },
     { commandId: 'snippet:pull', label: 'snippets', supportsYes: true },
 ];
 export default class Pull extends LoopressCommand {
-    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, from WordPress';
+    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -23,21 +25,26 @@ export default class Pull extends LoopressCommand {
     };
     failedCount = 0;
     async run() {
+        const results = [];
         for (const target of PULL_TARGETS) {
             this.log(`\n→ Pulling ${target.label}...`);
             try {
                 await this.config.runCommand(target.commandId, this.buildArgv(target));
                 this.log(`✓ ${target.label} pulled`);
+                results.push({ label: target.label, status: 'pulled' });
             }
             catch (error) {
                 this.failedCount++;
-                this.log(`✗ ${target.label} failed: ${error.message}`);
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
             }
         }
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'resource')} failed to pull.`);
         }
         this.log('\nAll resources pulled.');
+        return { results };
     }
     // `--yes` is forwarded only when the user passed it and the target accepts it: unlike
     // `lps push`, a bare `lps pull` should still prompt before removing local files.

package/dist/commands/push.d.ts

@@ -1,13 +1,23 @@
 import { LoopressCommand } from '../lib/base.js';
+type PushTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pushed';
+};
+type PushResult = {
+    results: PushTargetResult[];
+};
 export default class Push extends LoopressCommand {
     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>;
     };
     private failedCount;
-    run(): Promise<void>;
+    run(): Promise<PushResult>;
     private buildArgv;
     private guardProductionPush;
 }
+export {};

package/dist/commands/push.js

@@ -11,11 +11,13 @@ const PUSH_TARGETS = [
     { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
     { commandId: 'seo:push', label: 'SEO' },
+    { commandId: 'menu:push', label: 'menus' },
     { commandId: 'option:push', label: 'options' },
     { commandId: 'snippet:push', label: 'snippets' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, to WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -25,21 +27,26 @@ export default class Push extends LoopressCommand {
     async run() {
         await this.guardProductionPush();
         const argv = this.buildArgv();
+        const results = [];
         for (const target of PUSH_TARGETS) {
             this.log(`\n→ Pushing ${target.label}...`);
             try {
                 await this.config.runCommand(target.commandId, argv);
                 this.log(`✓ ${target.label} pushed`);
+                results.push({ label: target.label, status: 'pushed' });
             }
             catch (error) {
                 this.failedCount++;
-                this.log(`✗ ${target.label} failed: ${error.message}`);
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
             }
         }
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'resource')} failed to push.`);
         }
         this.log('\nAll resources pushed.');
+        return { results };
     }
     // Every delegated push always gets --yes: either this command's own guard already confirmed
     // production once above, or the target isn't production and there's nothing to confirm.

package/dist/commands/seo/pull.js

@@ -40,7 +40,9 @@ export default class Pull extends LoopressCommand {
             orphanReason: `in ${dir} no longer present on WordPress`,
             pulledMessage: `Pulled ${remote.length} ${postType} post-meta file(s) to ${dir}`,
             title: (post) => post.slug,
-            write: async (post, writeDir) => writeFile(join(writeDir, `${post.slug}.json`), JSON.stringify(post, null, 2) + '\n'),
+            // `revision` (#234) is never persisted locally, same as RemoteOption.revision: it's only
+            // ever read fresh, right before a push, never trusted from a stale local file.
+            write: async ({ meta, slug, title }, writeDir) => writeFile(join(writeDir, `${slug}.json`), JSON.stringify({ meta, slug, title }, null, 2) + '\n'),
         });
     }
     // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast). Unlike
@@ -71,7 +73,9 @@ export default class Pull extends LoopressCommand {
     }
     async pullSettings(basePath) {
         const file = join(basePath, 'settings.json');
-        const settings = await this.wp.get(SEO_SETTINGS_ENDPOINT);
+        // `revision` (#234) is never persisted locally, same as RemoteOption.revision: settings.json
+        // holds only the settings themselves, exactly as it did before the wrapped response shape.
+        const { settings } = await this.wp.get(SEO_SETTINGS_ENDPOINT);
         if (this.dryRun) {
             this.log(`[dry-run] Would pull settings to ${file}`);
             return;

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

@@ -12,6 +12,7 @@ export default class Push extends PushCommand {
     };
     private allowExternalRedirects;
     run(): Promise<void>;
+    private currentPostMetaRevision;
     private jsonFilesIn;
     private pushPostMeta;
     private pushPostMetaFile;

package/dist/commands/seo/push.js

@@ -4,8 +4,10 @@ import { dirname, extname, join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
 import { readdirTolerant } from '../../lib/readdir-tolerant.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
 import { pluralize } from '../../utils/pluralize.js';
-import { redirectFileBase, SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, seoRedirectEndpoint, } from '../../utils/seo-format.js';
+import { redirectFileBase, SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, seoPostMetaItemEndpoint, seoRedirectEndpoint, } from '../../utils/seo-format.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
@@ -28,9 +30,12 @@ export default class Push extends PushCommand {
         this.allowExternalRedirects = flags['allow-external-redirects'];
         this.log(`Pushing SEO configuration to ${url}`);
         this.log(`SEO path: ${path}`);
+        const provider = getResourceStateProvider('seo');
+        const beforeState = await this.captureBeforePushState(provider, path);
         await this.pushSettings(path);
         await this.pushPostMeta(path);
         await this.pushRedirects(path);
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'SEO item')} failed to push.`);
         }
@@ -39,6 +44,17 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         this.log('All SEO configuration pushed.');
     }
+    async currentPostMetaRevision(postType, slug) {
+        try {
+            const current = await this.wp.get(seoPostMetaItemEndpoint(postType, slug));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     async jsonFilesIn(dir) {
         return (await readdirTolerant(dir)).filter((file) => extname(file) === '.json');
     }
@@ -64,7 +80,16 @@ export default class Push extends PushCommand {
         }
         try {
             const post = JSON.parse(await readFile(filePath, 'utf8'));
-            await this.wp.post(seoPostMetaEndpoint(postType), { meta: post.meta, slug: post.slug });
+            // Read the post's current SEO-meta revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed that
+            // post's meta in between, instead of this push silently overwriting it (#234). No revision
+            // to condition on for a post whose meta doesn't exist remotely yet (an upsert that will
+            // itself fail with a clearer "post not found" error): falls back to an unconditional write.
+            const expectedRevision = await this.currentPostMetaRevision(postType, post.slug);
+            const body = { meta: post.meta, slug: post.slug };
+            if (expectedRevision !== undefined)
+                body.expectedRevision = expectedRevision;
+            await this.wp.post(seoPostMetaEndpoint(postType), body);
             if (task)
                 task.output = `Pushed: ${post.slug}`;
         }
@@ -128,7 +153,12 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.put(SEO_SETTINGS_ENDPOINT, JSON.parse(raw));
+            const settings = JSON.parse(raw);
+            // Read the settings' current revision right before writing them, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // settings in between, instead of this push silently overwriting it (#234).
+            const { revision } = await this.wp.get(SEO_SETTINGS_ENDPOINT);
+            await this.wp.put(SEO_SETTINGS_ENDPOINT, { expectedRevision: revision, settings });
             this.log(`Pushed: ${file}`);
         }
         catch (error) {

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

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

package/dist/commands/seo/rollback.js

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

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

@@ -19,6 +19,7 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private currentRevision;
     private ensureCanonicalFilename;
     private loadSnippets;
     private pushSnippet;

package/dist/commands/snippet/push.js

@@ -4,6 +4,8 @@ import { basename, dirname, extname, join } from 'node:path';
 import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 import { toSlug } from '../../utils/to-slug.js';
@@ -24,6 +26,8 @@ export default class Push extends PushCommand {
         const path = this.resolveSnippetsPath(args.path);
         this.log(`Pushing snippets to ${url}`);
         this.log(`Snippets path: ${path}`);
+        const provider = getResourceStateProvider('snippet');
+        const beforeState = await this.captureBeforePushState(provider, path);
         const snippets = await this.loadSnippets(path);
         this.log(`Found ${pluralize(snippets.length, 'snippet')} to push`);
         const pushed = [];
@@ -31,6 +35,7 @@ export default class Push extends PushCommand {
             const id = await this.pushSnippet(snippet, task);
             pushed.push({ id, name: snippet.name });
         });
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'snippet')} failed to push.`);
         }
@@ -40,6 +45,17 @@ export default class Push extends PushCommand {
         this.log('All snippets pushed.');
         return { pushed, status: 'success' };
     }
+    async currentRevision(id) {
+        try {
+            const current = await this.wp.get(`${SNIPPETS_ENDPOINT}/${id}`);
+            return normalizeSnippet(current).revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     // Renames the local file pair to the `<id>-<slug>` convention used by `snippet pull` whenever
     // it doesn't already match (e.g. a hand-created `demo.php` with no id, or a stale slug after a rename).
     // This is a side effect of `push`: local files on disk are renamed, not just the remote snippet.
@@ -90,12 +106,26 @@ export default class Push extends PushCommand {
         }
         try {
             const payload = this.toPayload(snippet);
+            // Read the snippet's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // snippet in between, instead of this push silently overwriting it (#234). No revision to
+            // condition on when there's no known remote id yet (a first push): putPayload then equals
+            // payload, and putOrCreate falls back to POST below exactly as before this existed. Kept
+            // out of the POST body specifically (see postPayload): a spurious expectedRevision on a
+            // create would be meaningless there.
+            let putPayload = payload;
+            if (snippet.id !== undefined) {
+                const expectedRevision = await this.currentRevision(snippet.id);
+                if (expectedRevision !== undefined)
+                    putPayload = { ...payload, expectedRevision };
+            }
             // The id recorded locally may not exist on this site (e.g. a fresh install): putOrCreate
             // falls back to POST instead of failing, adopting whatever id the site assigns.
             const { body, created } = await putOrCreate(this.wp, {
                 id: snippet.id ?? null,
-                payload,
+                payload: putPayload,
                 postEndpoint: SNIPPETS_ENDPOINT,
+                postPayload: payload,
                 putEndpoint: (id) => `${SNIPPETS_ENDPOINT}/${id}`,
             });
             let { id } = snippet;

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

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