@loopress/cli 0.29.0 → 0.31.0

package/dist/lib/diff-command.js

@@ -47,8 +47,16 @@ export class DiffCommand extends LoopressCommand {
     // a tally, and the verdict, then returns the structured result. Exit code: 1 on drift, 2
     // when a resource could not be compared (inconclusive), so the command doubles as a CI gate.
     async report(targets, sides) {
-        this.out(`Comparing ${c('bold', sides.leftLabel)} ${c('dim', '→')} ${c('bold', sides.rightLabel)}\n`);
+        this.out(`Comparing ${c('bold', sides.leftLabel)} ${c('dim', '→')} ${c('bold', sides.rightHeading)}\n`);
         const results = await Promise.all(targets.map(async (target) => this.computeResource(target, sides)));
+        // Every resource failing the same way (site down, bad credentials) is one problem: say it
+        // once instead of once per resource.
+        const sharedError = sharedFailure(results.map((result) => result.json.error));
+        if (sharedError !== undefined) {
+            // Named, since some resources may have compared fine (one that needs no request).
+            const failedTitles = results.filter((result) => result.json.error !== undefined).map((result) => result.title);
+            this.out(c('red', `error (${failedTitles.join(', ')}): ${sharedError}`));
+        }
         const resources = {};
         let drift = false;
         let failed = false;
@@ -60,8 +68,7 @@ export class DiffCommand extends LoopressCommand {
             resources[result.resource] = result.json;
             if (result.json.error !== undefined) {
                 failed = true;
-                const errorLabel = c('red', `error: ${result.json.error}`);
-                this.out(`${c('bold', result.title)}  ${errorLabel}`);
+                this.renderFailure(result.title, result.json.error, sharedError);
                 continue;
             }
             compared += 1;
@@ -91,6 +98,7 @@ export class DiffCommand extends LoopressCommand {
         return {
             againstWp: against ? this.wpForEnvironment(against) : undefined,
             leftLabel: this.siteConfig.name,
+            rightHeading: against ?? 'local files',
             rightLabel: against ?? 'local',
             warn: (message) => {
                 this.warn(message);
@@ -120,6 +128,13 @@ export class DiffCommand extends LoopressCommand {
         if (!this.jsonEnabled())
             this.log(message);
     }
+    renderFailure(title, error, sharedError) {
+        // Already printed once by `report` when every failure is the same.
+        if (sharedError !== undefined)
+            return;
+        const errorLabel = c('red', `error: ${error}`);
+        this.out(`${c('bold', title)}  ${errorLabel}`);
+    }
     renderSection(title, stateDiff) {
         if (isEmptyDiff(stateDiff)) {
             this.out(`${c('bold', title)}  ${c('dim', 'in sync')}`);
@@ -180,3 +195,9 @@ function indentPatch(patch) {
         .join('\n')
         .trimEnd();
 }
+// The one error every failed resource shares, when more than one failed (see `report`).
+function sharedFailure(errors) {
+    const failures = errors.filter((error) => error !== undefined);
+    const distinct = new Set(failures);
+    return failures.length > 1 && distinct.size === 1 ? failures[0] : undefined;
+}

package/dist/lib/github-release.js

@@ -4,6 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
+import { withSpinner } from './spinner.js';
 const REPO = 'loopress/loopress';
 const ASSET_NAME = 'loopress-full.zip';
 /**
@@ -17,6 +18,9 @@ const ASSET_NAME = 'loopress-full.zip';
  * "the one zip asset".
  */
 export async function downloadLatestFullZip() {
+    return withSpinner('Downloading Loopress Full', download);
+}
+async function download() {
     const releases = await got(`https://api.github.com/repos/${REPO}/releases`, {
         headers: { accept: 'application/vnd.github+json', 'user-agent': 'loopress-cli' },
         searchParams: { 'per_page': 30 },

package/dist/lib/load-snippets.js

@@ -26,6 +26,7 @@ async function loadSnippet(path, file, onSkip) {
     }
     let id;
     let name;
+    let description;
     let type;
     let isActive = false;
     let tags = [];
@@ -40,6 +41,8 @@ async function loadSnippet(path, file, onSkip) {
         // `||`, not `??`: an empty-string name in the sidecar JSON counts as absent too.
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         name = meta.name || undefined;
+        // Kept even when empty: a description cleared on purpose, not one to replace with "Imported from <path>".
+        description = meta.description;
         type = parseType(meta.type) ?? undefined;
         isActive = Boolean(meta.active);
         tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
@@ -58,6 +61,7 @@ async function loadSnippet(path, file, onSkip) {
     return {
         active: isActive,
         code: content,
+        description,
         id,
         insertMethod: insertMethod ?? 'auto',
         location: location ?? defaultLocationForType(resolvedType),

package/dist/lib/local-callback-server.js

@@ -2,6 +2,7 @@ import { Buffer } from 'node:buffer';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { openBrowser } from './open-browser.js';
+import { withSpinner } from './spinner.js';
 /** Constant-time compare that also tolerates a length mismatch without throwing. */
 function safeEqual(a, b) {
     const bufferA = Buffer.from(a);
@@ -28,7 +29,7 @@ function safeEqual(a, b) {
 export async function waitForLocalCallback(options) {
     const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
     const state = randomBytes(32).toString('hex');
-    return new Promise((resolve, reject) => {
+    const callback = new Promise((resolve, reject) => {
         function finish(res, page) {
             // `Connection: close` (here and below): server.close() only refuses new connections, a
             // kept-alive socket would otherwise still reach this handler after the shutdown.
@@ -100,6 +101,7 @@ export async function waitForLocalCallback(options) {
             openBrowser(targetUrl);
         });
     });
+    return withSpinner('Waiting for the browser', async () => callback);
 }
 /**
  * The page rewrites its own URL to `/` on load, so the callback query string (an Application

package/dist/lib/php-files-command.d.ts

@@ -30,7 +30,15 @@ type RemotePhpFile = {
     filename: string;
     public?: boolean;
     revision?: string;
+    runtimeError?: RuntimeError;
 };
+export type RuntimeError = {
+    at: string;
+    message: string;
+    method: string;
+    type: 'action' | 'cron' | 'filter';
+};
+export declare function formatRuntimeError(error: RuntimeError): string;
 type PushResult = {
     pruned: string[];
     pushed: string[];

package/dist/lib/php-files-command.js

@@ -14,6 +14,9 @@ import { loadFiles as loadDirectoryFiles } from './load-files.js';
 import { PushCommand } from './push-command.js';
 import { getResourceStateProvider } from './resource-state.js';
 import { isApplicative404 } from './wp-client.js';
+export function formatRuntimeError(error) {
+    return `${error.method}() threw while running as ${error.type === 'action' ? 'an' : 'a'} ${error.type}, last at ${error.at}: ${error.message}`;
+}
 // Mirrors wordpress-plugin FileWriter::DECLARE_PATTERN / withGuard(): the server rejects both
 // an absent declare(strict_types=1); and one that appears more than once (it needs a single
 // unambiguous insertion point for the ABSPATH guard). Matching "exactly once" here, not just
@@ -262,6 +265,8 @@ export function resourceListCommand(spec) {
             for (const file of files) {
                 const badges = [file.public ? '[PUBLIC]' : '', file.error ? `(${file.error})` : ''].filter(Boolean).join('  ');
                 this.log(badges ? `  ${file.filename}  ${badges}` : `  ${file.filename}`);
+                if (file.runtimeError)
+                    this.log(`    ${formatRuntimeError(file.runtimeError)}`);
             }
             if (files.some((file) => file.public)) {
                 this.log('');

package/dist/lib/push-command.d.ts

@@ -3,18 +3,20 @@ import { type ResourceState } from './diff-state.js';
 import { type ResourceStateProvider } from './resource-state.js';
 export declare abstract class PushCommand extends LoopressCommand {
     static baseFlags: {
+        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'production-confirmed': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     protected failedCount: number;
     private refusedByGuard;
-    protected captureBeforePushState(provider: ResourceStateProvider, dir: string): Promise<ResourceState | undefined>;
+    protected captureBeforePushState(provider: ResourceStateProvider, dir: string, writes?: (id: string) => boolean): Promise<ResourceState | undefined>;
     catch(err: Error): Promise<void>;
     protected guardProductionPush(): Promise<void>;
     init(): Promise<void>;
-    protected previewRemote(provider: ResourceStateProvider, dir: string): Promise<void>;
+    protected previewRemote(provider: ResourceStateProvider, dir: string): Promise<ResourceState>;
     protected recordDeployment(status: 'failure' | 'success'): Promise<void>;
     protected recordSuccess(): Promise<void>;
+    protected reportPushToSite(): Promise<void>;
     protected reportTaskFailure(message: string, error: unknown, task?: {
         output: string;
     }): never;
@@ -22,4 +24,5 @@ export declare abstract class PushCommand extends LoopressCommand {
         output: string;
     }) => Promise<void>): Promise<void>;
     protected writeAfterPushSnapshot(provider: ResourceStateProvider, dir: string, beforeState: ResourceState | undefined): Promise<void>;
+    private guardOutsideEdits;
 }

package/dist/lib/push-command.js

@@ -1,17 +1,22 @@
+import { confirm } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import got from 'got';
 import { Listr } from 'listr2';
 import { resolve } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { authManager } from '../config/auth.manager.js';
 import { API_URL } from './api-client.js';
 import { LoopressCommand } from './base.js';
 import { guardProductionPush } from './guard-production-push.js';
-import { writeSnapshot } from './snapshot-store.js';
+import { isInteractive } from './interactive.js';
+import { readSnapshot, recordToState, writeSnapshot } from './snapshot-store.js';
+import { withoutSpinner, withSpinner } from './spinner.js';
 export class PushCommand extends LoopressCommand {
     // Passed by an aggregate command (`lps theme push`) that already confirmed production once,
     // so its steps skip that prompt while still asking their own confirmations (uninstalls).
     static baseFlags = {
         ...LoopressCommand.baseFlags,
+        overwrite: Flags.boolean({ description: 'Push even over changes made on the site outside Loopress since your last push' }),
         'production-confirmed': Flags.boolean({ hidden: true }),
     };
     failedCount = 0;
@@ -25,13 +30,17 @@ export class PushCommand extends LoopressCommand {
     // `writeAfterPushSnapshot` there is no restore point to complete.
     //
     // On a dry run, the same read is the preview's check against the site (see previewRemote).
-    async captureBeforePushState(provider, dir) {
+    //
+    // `writes` narrows the outside-edit check to the ids this push actually writes, for a push that
+    // skips some local items (`lps page push <slug>`, readonly options, `lps acf push --type`).
+    async captureBeforePushState(provider, dir, writes) {
         if (this.dryRun) {
-            await this.previewRemote(provider, dir);
+            await this.guardOutsideEdits(provider, dir, await this.previewRemote(provider, dir), writes);
             return undefined;
         }
+        let remote;
         try {
-            return await provider.remote(this.wp, (message) => {
+            remote = await provider.remote(this.wp, (message) => {
                 this.warn(message);
             }, dir);
         }
@@ -39,6 +48,8 @@ export class PushCommand extends LoopressCommand {
             this.warn(`Could not read remote state for a rollback snapshot: ${error.message}`);
             return undefined;
         }
+        await this.guardOutsideEdits(provider, dir, remote, writes);
+        return remote;
     }
     async catch(err) {
         if (!this.dryRun && !this.refusedByGuard && this.siteConfig) {
@@ -67,7 +78,7 @@ export class PushCommand extends LoopressCommand {
     // pre-apply check built on it, see what the real push will hit.
     async previewRemote(provider, dir) {
         try {
-            await provider.remote(this.wp, () => { }, dir);
+            return await provider.remote(this.wp, () => { }, dir);
         }
         catch (error) {
             this.error(`The site would refuse this push: ${error.message}`);
@@ -78,19 +89,37 @@ export class PushCommand extends LoopressCommand {
         if (!token)
             return;
         try {
-            await got.post(`${API_URL}/deployments`, {
+            await withSpinner('Recording the deployment', async () => got.post(`${API_URL}/deployments`, {
                 headers: { Authorization: `Bearer ${token}` },
                 json: { status, url: this.siteConfig.url },
                 timeout: { request: 3000 },
-            });
+            }));
         }
         catch {
             // non-blocking: recording must never interrupt the push flow
         }
     }
     async recordSuccess() {
-        if (!this.dryRun)
-            await this.recordDeployment('success');
+        if (this.dryRun)
+            return;
+        await this.recordDeployment('success');
+        await this.reportPushToSite();
+    }
+    // Tells the plugin this push finished, for its Overview tab and the "managed by Loopress"
+    // warnings in wp-admin: one record per command (`this.id`, e.g. `acf:push`), since a single push
+    // sends one request per item. Best-effort like recordDeployment: a plugin older than the push
+    // log answers 404, one that doesn't know this command 400, neither may fail a push that landed.
+    async reportPushToSite() {
+        if (!this.id)
+            return;
+        try {
+            // Bounded: the site fingerprints the pushed resource before answering, which a large
+            // site can make slow, and a finished push must not wait on its own bookkeeping.
+            await this.wp.post('loopress/v1/pushes', { resource: this.id }, { timeoutMs: 5000 });
+        }
+        catch {
+            // non-blocking, see above
+        }
     }
     // Reports one failed Listr task: status lines go through `task.output` when running inside a
     // Listr renderer (this.warn would race with the repaint), and fall back to `this.warn` when
@@ -111,17 +140,19 @@ export class PushCommand extends LoopressCommand {
     // just the first. `label` feeds the "Push <label>" task title; `task` does the actual work
     // and reports its own failure through `reportTaskFailure`.
     async runPushTasks(items, label, task) {
-        await new Listr(items.map((item) => ({
-            task: async (_ctx, taskCtx) => task(item, taskCtx),
-            title: `Push ${label(item)}`,
-        })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        await withoutSpinner(async () => {
+            await new Listr(items.map((item) => ({
+                task: async (_ctx, taskCtx) => task(item, taskCtx),
+                title: `Push ${label(item)}`,
+            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        });
     }
     // Pairs `beforeState` (from captureBeforePushState, read before this push touched anything)
     // with a fresh remote read taken right after the push, and writes both as one rollback
     // snapshot. Reading the after-state from WordPress itself, rather than assuming it matches
     // the local files that were pushed, is what keeps this correct for every resource's own
-    // partial-push semantics: a readonly option skipped by `option push`, a snippet or SEO
-    // redirect that gets a server-assigned id on create, a theme-styles push that only touches the
+    // partial-push semantics: a readonly option skipped by `option push`, a snippet or form
+    // that gets a server-assigned id on create, a theme-styles push that only touches the
     // active stylesheet, an API/hook push that leaves server-side files alone unless `--prune`.
     // `lps <resource> rollback`'s drift check compares the environment's state at rollback time
     // against exactly this after-state, so it has to be what actually landed, not what was sent.
@@ -144,4 +175,54 @@ export class PushCommand extends LoopressCommand {
             this.warn(`Could not save a rollback snapshot after this push: ${error.message}`);
         }
     }
+    // Refuses to silently overwrite a change made on the site outside Loopress (wp-admin, another
+    // tool) since this machine's last push. Flags an id only when both hold:
+    // - the site no longer matches what that push left (the latest snapshot's `afterState`, the
+    //   same reference rollback's drift check uses), and
+    // - this push would write a different value over it (local differs from the site), so a
+    //   `pull` that already brought the change into the local files is no reason to stop.
+    // Only ids present locally count: a push is additive, it never touches a site-only id. And
+    // only ids the site still has with readable content: pushing over a deletion (`lps <resource>
+    // rm`, or wp-admin) loses nothing, and a file the site lists without its content (too large
+    // to send) can't be compared, so it would otherwise block every push.
+    // Ceiling: snapshots live in git-ignored `.loopress/`, so only the machine that pushed last
+    // is protected; a record kept on the site would cover teammates and CI.
+    async guardOutsideEdits(provider, dir, remote, writes) {
+        if (this.overwrite)
+            return;
+        let expected;
+        let local;
+        let pushedAt;
+        try {
+            const snapshot = await readSnapshot(resolve(process.cwd(), this.rootDir), provider.resource, this.siteConfig.name);
+            expected = recordToState(snapshot.afterState);
+            pushedAt = snapshot.createdAt;
+            local = await provider.local(dir, () => { });
+        }
+        catch {
+            // No earlier push from this machine, or unreadable local files the push reports itself.
+            return;
+        }
+        const overwritten = [...local.keys()].filter((id) => (writes?.(id) ?? true) &&
+            remote.get(id) !== undefined &&
+            !sameEntry(remote, expected, id) &&
+            !sameEntry(local, remote, id));
+        if (overwritten.length === 0)
+            return;
+        const message = `Changed on ${this.siteConfig.url} outside Loopress since your last push (${pushedAt}), this push would overwrite: ${overwritten.join(', ')}. ` +
+            `Review with \`lps diff --only ${provider.resource}\`, bring the site's version into your files, or pass --overwrite.`;
+        // A dry run only previews: say what the real push would stop on.
+        if (this.dryRun) {
+            this.warn(message);
+            return;
+        }
+        if (!isInteractive())
+            this.error(message);
+        this.warn(message);
+        if (!(await confirm({ default: false, message: 'Overwrite those changes?' })))
+            this.error('Aborted.');
+    }
+}
+function sameEntry(left, right, id) {
+    return left.has(id) === right.has(id) && isDeepStrictEqual(left.get(id), right.get(id));
 }

package/dist/lib/put-or-create.js

@@ -1,8 +1,7 @@
 import { isNotFoundError } from './wp-client.js';
-// Update-or-create dance shared by every id-based resource (form, seo redirect,
-// snippet, unlike ACF which is key-based and only ever POSTs): PUT to the known id, and only
-// fall back to POST when the site doesn't recognize that id (404), e.g. a fresh install or a
-// database reset.
+// Update-or-create dance shared by every id-based resource (form, snippet, unlike ACF which
+// is key-based and only ever POSTs): PUT to the known id, and only fall back to POST when the
+// site doesn't recognize that id (404), e.g. a fresh install or a database reset.
 export async function putOrCreate(wp, options) {
     const { id, payload, postEndpoint, postPayload = payload, putEndpoint } = options;
     if (id !== null) {

package/dist/lib/resource-state.js

@@ -1,11 +1,11 @@
 import { readFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../utils/acf-format.js';
+import { CPT_SPEC, fileExtension, META_SPEC, parseDeclaredFile, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC, } from '../utils/declared-type-format.js';
 import { FORM_ENDPOINT, getFormId } from '../utils/form-format.js';
 import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../utils/menu-format.js';
 import { optionEndpoint, parseLocalOption } from '../utils/option-format.js';
 import { formatPageProblems, PAGES_ENDPOINT, readLocalHtmlFiles, readLocalPages } from '../utils/page-format.js';
-import { DEFAULT_POST_TYPES, SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, } from '../utils/seo-format.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../utils/snippet-format.js';
 import { CHILD_THEME_ENDPOINT, parsePartFile, parseTemplateFile, TEMPLATE_SLUG_RULE } from '../utils/template-format.js';
 import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, THEME_STYLES_FILE_SUFFIX, } from '../utils/theme-styles-format.js';
@@ -30,17 +30,15 @@ function omit(object, keys) {
 const ACF_VOLATILE_KEYS = ['modified'];
 // A WPForms form is a WP post; `modified`/`modified_gmt` move on every edit.
 const FORM_VOLATILE_KEYS = ['modified', 'modified_gmt'];
-// A RankMath redirect's `hits` is a live visit counter.
-const REDIRECT_VOLATILE_KEYS = ['hits'];
 // ---- snippets -------------------------------------------------------------------------------
-// `description` is dropped: `snippet push` overwrites it with "Imported from <path>" on every
-// push and `loadSnippets` never reads it back, so it is not part of the synced state. `id`
-// becomes the map key. `code` has its leading `<?php` stripped on both sides: `snippet pull`
-// re-adds it to PHP files for editor friendliness, WordPress stores only the body.
+// `description` is dropped: a sidecar without one gets "Imported from <path>" on push, so
+// comparing it would flag every such snippet as drifted. `id` becomes the map key. A PHP
+// snippet's `code` has its leading `<?php` stripped on both sides: `snippet pull` re-adds it
+// for editor friendliness, WordPress stores only the body. Other types keep it, it's content.
 function canonicalSnippet(snippet) {
     return {
         active: snippet.active,
-        code: stripPhpOpeningTag(snippet.code),
+        code: snippet.type === 'php' ? stripPhpOpeningTag(snippet.code) : snippet.code,
         insertMethod: snippet.insertMethod,
         location: snippet.location,
         name: snippet.name,
@@ -257,82 +255,6 @@ const partProvider = {
     resource: 'part',
     title: 'Template parts',
 };
-// ---- SEO --------------------------------------------------------------------------------
-function canonicalRedirect(redirect) {
-    return omit(redirect, REDIRECT_VOLATILE_KEYS);
-}
-const seoProvider = {
-    dirKind: 'seo',
-    async local(dir, onWarn) {
-        const state = new Map();
-        // The provider settings blob (Yoast / RankMath) is compared whole. If a real payload turns
-        // out to carry install-specific noise (a plugin version, a license hash), add those keys
-        // to an omit() list here, the e2e round-trip is what will surface them.
-        const settingsPath = join(dir, 'settings.json');
-        try {
-            const settings = readJson(await readFile(settingsPath, 'utf8'));
-            state.set('settings', settings);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                onWarn(`Skipping "${settingsPath}": ${error.message}`);
-            }
-        }
-        for (const postType of DEFAULT_POST_TYPES) {
-            const metaDir = join(dir, 'post-meta', postType);
-            const entries = await loadFiles(metaDir, {
-                extension: '.json',
-                onSkip: onWarn,
-                parse: (raw, filePath) => ({ file: basename(filePath, '.json'), value: readJson(raw) }),
-            });
-            for (const { file, value } of entries) {
-                const slug = typeof value.slug === 'string' && value.slug !== '' ? value.slug : `local:${file}`;
-                state.set(`post-meta/${postType}/${slug}`, value);
-            }
-        }
-        const redirects = await loadFiles(join(dir, 'redirects'), {
-            extension: '.json',
-            onSkip: onWarn,
-            parse: readJson,
-        });
-        for (const redirect of redirects) {
-            const id = Number(redirect.id);
-            if (Number.isSafeInteger(id) && id > 0)
-                state.set(`redirects/${id}`, canonicalRedirect(redirect));
-        }
-        return state;
-    },
-    async remote(wp, onWarn) {
-        const state = new Map();
-        // `revision` (#234) is dropped from both, same as optionsProvider.remote() does for
-        // RemoteOption.revision below: it's bookkeeping for the conditional-write precondition, not
-        // configuration, and comparing it here would flag drift whenever the mere act of reading
-        // changed nothing meaningful.
-        const { settings } = await wp.get(SEO_SETTINGS_ENDPOINT);
-        state.set('settings', settings);
-        for (const postType of DEFAULT_POST_TYPES) {
-            const posts = await wp.get(seoPostMetaEndpoint(postType));
-            for (const { meta, slug, title } of posts)
-                state.set(`post-meta/${postType}/${slug}`, { meta, slug, title });
-        }
-        // Redirects are a RankMath-only feature; on Yoast the endpoint 404s, same graceful skip
-        // as `seo pull`.
-        try {
-            const redirects = await wp.get(SEO_REDIRECTS_ENDPOINT);
-            for (const redirect of redirects) {
-                state.set(`redirects/${redirect.id}`, canonicalRedirect(redirect));
-            }
-        }
-        catch (error) {
-            if (!isNotFoundError(error))
-                throw error;
-            onWarn(`Skipping redirects: not supported by the active SEO plugin`);
-        }
-        return state;
-    },
-    resource: 'seo',
-    title: 'SEO',
-};
 // ---- Menus --------------------------------------------------------------------------------
 // Every item's post_type/taxonomy target is already resolved to `object`/`objectSlug` by the
 // REST layer (MenuService), never a raw `_menu_item_object_id`, so the exported tree is already
@@ -382,6 +304,33 @@ const menuProvider = {
     resource: 'menu',
     title: 'Menus',
 };
+// ---- Custom post types, taxonomies, post meta, roles and patterns ---------------------------------------
+// Keyed by slug (the local file name), compared on the bare arguments: `revision` is push
+// bookkeeping, never part of the file.
+function declaredTypeProvider(spec, title) {
+    return {
+        dirKind: spec.dirKind,
+        async local(dir, onWarn) {
+            const entries = await loadFiles(dir, {
+                extension: fileExtension(spec),
+                onSkip: onWarn,
+                parse: (raw, filePath) => parseDeclaredFile(spec, filePath, raw),
+            });
+            return new Map(entries.map(({ args, slug }) => [slug, args]));
+        },
+        async remote(wp) {
+            const items = await wp.get(spec.endpoint);
+            return new Map(items.map(({ args, slug }) => [slug, args]));
+        },
+        resource: spec.cliName,
+        title,
+    };
+}
+const cptProvider = declaredTypeProvider(CPT_SPEC, 'Post types');
+const taxonomyProvider = declaredTypeProvider(TAXONOMY_SPEC, 'Taxonomies');
+const metaProvider = declaredTypeProvider(META_SPEC, 'Post meta');
+const roleProvider = declaredTypeProvider(ROLE_SPEC, 'Roles');
+const patternProvider = declaredTypeProvider(PATTERN_SPEC, 'Patterns');
 // ---- Options ------------------------------------------------------------------------------
 // Unlike every provider above, remote() has no "everything" endpoint to read: GET /options only
 // lists names, never values (by design, see OptionsController), so both sides compare exactly
@@ -470,8 +419,12 @@ export const RESOURCE_STATE_PROVIDERS = [
     templateProvider,
     partProvider,
     pageProvider,
-    seoProvider,
     menuProvider,
+    cptProvider,
+    taxonomyProvider,
+    metaProvider,
+    roleProvider,
+    patternProvider,
     optionsProvider,
     themeStylesProvider,
 ];

package/dist/lib/rollback-command.js

@@ -126,8 +126,15 @@ export function resourceRollbackCommand(resource, options) {
                 // commands/snippet/push.ts's `static args`), not a --path flag. --env/--yes: the
                 // production guard and the drift confirmation above already covered what the delegated
                 // push's own guard would ask again, same reasoning as the top-level `lps push`
-                // delegating to each resource's push command in commands/push.ts.
-                await this.config.runCommand(`${command.replaceAll(' ', ':')}:push`, [tmpDir, '--env', this.siteConfig.name, '--yes']);
+                // delegating to each resource's push command in commands/push.ts. --overwrite: the drift
+                // check above is the same question as the push's outside-edit check, already answered.
+                await this.config.runCommand(`${command.replaceAll(' ', ':')}:push`, [
+                    tmpDir,
+                    '--env',
+                    this.siteConfig.name,
+                    '--yes',
+                    '--overwrite',
+                ]);
             }
             finally {
                 // A cleanup failure here must never hide a real error from the push above: warn about

package/dist/lib/rollback-materialize.js

@@ -1,10 +1,10 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { getAcfKey } from '../utils/acf-format.js';
+import { CPT_SPEC, fileExtension, formatDeclaredFile, META_SPEC, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC } from '../utils/declared-type-format.js';
 import { getFormId, getFormTitle } from '../utils/form-format.js';
 import { getMenuSlug } from '../utils/menu-format.js';
 import { defaultReadonlyFor, optionFileName } from '../utils/option-format.js';
-import { redirectFileBase } from '../utils/seo-format.js';
 import { buildMetaFile, buildSnippetFile } from '../utils/snippet-format.js';
 import { themeStylesFileName } from '../utils/theme-styles-format.js';
 import { toSlug } from '../utils/to-slug.js';
@@ -51,28 +51,6 @@ async function phpFile(id, value, dir) {
     await mkdir(dirname(filePath), { recursive: true });
     await writeFile(filePath, String(value));
 }
-// ids are 'settings', `post-meta/<postType>/<slug>`, or `redirects/<id>` (see resource-state.ts's
-// seoProvider). Each value round-trips to the exact file `seo pull` would have written.
-async function seo(id, value, dir) {
-    if (id === 'settings') {
-        await writeJson(join(dir, 'settings.json'), value);
-        return;
-    }
-    if (id.startsWith('post-meta/')) {
-        const rest = id.slice('post-meta/'.length);
-        const separator = rest.indexOf('/');
-        const postType = rest.slice(0, separator);
-        const slug = rest.slice(separator + 1);
-        await writeJson(join(dir, 'post-meta', postType, `${slug}.json`), value);
-        return;
-    }
-    if (id.startsWith('redirects/')) {
-        const redirect = value;
-        await writeJson(join(dir, 'redirects', `${redirectFileBase(redirect)}.json`), redirect);
-        return;
-    }
-    throw new Error(`Unrecognized SEO snapshot id "${id}"`);
-}
 // ids are 'menu-locations' or `menu/<slug>` (see resource-state.ts's menuProvider).
 async function menu(id, value, dir) {
     if (id === 'menu-locations') {
@@ -97,15 +75,26 @@ async function option(id, value, dir) {
 async function themeStyles(id, value, dir) {
     await writeJson(join(dir, themeStylesFileName(id)), value);
 }
+// id is the slug, value the bare register_*() arguments (resource-state.ts's declaredTypeProvider),
+// written in the spec's file format like `<resource> pull` does.
+function declaredType(spec) {
+    return async (id, value, dir) => {
+        await writeFile(join(dir, `${id}${fileExtension(spec)}`), formatDeclaredFile(spec, value));
+    };
+}
 const MATERIALIZERS = {
     acf,
     api: phpFile,
+    cpt: declaredType(CPT_SPEC),
     form,
     hook: phpFile,
     menu,
+    meta: declaredType(META_SPEC),
     option,
-    seo,
+    pattern: declaredType(PATTERN_SPEC),
+    role: declaredType(ROLE_SPEC),
     snippet,
+    taxonomy: declaredType(TAXONOMY_SPEC),
     'theme-styles': themeStyles,
 };
 // Writes a snapshot's state back to `dir` in the exact on-disk layout `<resource> pull` would

package/dist/lib/spinner.d.ts

@@ -0,0 +1,2 @@
+export declare function withSpinner<T>(message: string, work: () => Promise<T>): Promise<T>;
+export declare function withoutSpinner<T>(work: () => Promise<T>): Promise<T>;