@loopress/cli 0.24.1 → 0.25.0

package/dist/commands/snippet/rollback.js

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

package/dist/commands/theme-styles/diff.d.ts

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

package/dist/commands/theme-styles/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('theme-styles', {
+    description: "Show what differs in the active block theme's Global Styles (Site Editor > Styles) between your local file and a WordPress environment, or between two environments",
+    pathNoun: 'theme styles directory',
+});

package/dist/commands/theme-styles/pull.d.ts

@@ -0,0 +1,12 @@
+import { LoopressCommand } from '../../lib/base.js';
+export default class Pull extends LoopressCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/theme-styles/pull.js

@@ -0,0 +1,31 @@
+import { Args } from '@oclif/core';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName, } from '../../utils/theme-styles-format.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
+    };
+    static description = "Pull the active block theme's Global Styles customizations (Site Editor > Styles) from WordPress into a local file";
+    static examples = ['$ lps theme-styles pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const dir = this.resolveThemeStylesPath(args.path);
+        this.log(`Pulling Global Styles from ${url}`);
+        const { id, stylesheet } = await getActiveThemeGlobalStyles(this.wp);
+        const item = await this.wp.get(globalStylesEndpoint(id));
+        const file = join(dir, themeStylesFileName(stylesheet));
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull Global Styles for "${stylesheet}" to ${file}`);
+            return;
+        }
+        await mkdir(dir, { recursive: true });
+        await writeFile(file, JSON.stringify(canonicalGlobalStyles(item), null, 2) + '\n');
+        this.log(`Pulled Global Styles for "${stylesheet}" to ${file}`);
+    }
+}

package/dist/commands/theme-styles/push.d.ts

@@ -0,0 +1,12 @@
+import { PushCommand } from '../../lib/push-command.js';
+export default class Push extends PushCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/theme-styles/push.js

@@ -0,0 +1,45 @@
+import { Args } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { PushCommand } from '../../lib/push-command.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../utils/theme-styles-format.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
+    };
+    static description = "Push the local Global Styles file to the active block theme's Site Editor > Styles on WordPress";
+    static examples = ['$ lps theme-styles push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const dir = this.resolveThemeStylesPath(args.path);
+        this.log(`Pushing Global Styles to ${url}`);
+        const { id, stylesheet } = await getActiveThemeGlobalStyles(this.wp);
+        const file = join(dir, themeStylesFileName(stylesheet));
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme-styles pull\` first.`);
+            }
+            throw error;
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${file}`);
+            return;
+        }
+        const provider = getResourceStateProvider('theme-styles');
+        const beforeState = await this.captureBeforePushState(provider, dir);
+        const local = JSON.parse(raw);
+        await this.wp.post(globalStylesEndpoint(id), { settings: local.settings ?? {}, styles: local.styles ?? {} });
+        this.log(`Pushed: ${file}`);
+        await this.writeAfterPushSnapshot(provider, dir, beforeState);
+        await this.recordSuccess();
+    }
+}

package/dist/commands/theme-styles/rollback.d.ts

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

package/dist/commands/theme-styles/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('theme-styles', {
+    description: 'Restore the active theme’s Global Styles to a snapshot taken automatically before an earlier `lps theme-styles push`',
+    pathNoun: 'theme styles directory',
+});

package/dist/lib/app-manifest.js

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, join, relative } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { walkFiles } from './readdir-tolerant.js';
 export const APP_CONFIG_FILENAME = 'loopress.app.json';
 const DEFAULT_ASSETS_DIR = 'dist';
 // Static assets a bundler emits, mirrors the server's AppsDirectory::ALLOWED_EXTENSIONS.
@@ -14,35 +15,11 @@ const ALLOWED_EXTENSIONS = new Set([
 export function isAllowedAsset(relPath) {
     return ALLOWED_EXTENSIONS.has(extname(relPath).toLowerCase());
 }
-async function walk(dir, root) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const out = [];
-    for (const entry of entries) {
-        const abs = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            out.push(...(await walk(abs, root)));
-        }
-        else if (entry.isFile()) {
-            // Identity is always '/'-joined, never the OS separator: it travels over HTTP and is
-            // matched against the server's own '/'-joined paths.
-            out.push(relative(root, abs).replaceAll(/[\\/]/g, '/'));
-        }
-    }
-    return out;
-}
 // Builds the sorted file list of a dist directory. Throws on a file whose extension the
 // server would reject, so the push fails locally with a clear message instead of a 400
 // halfway through the upload.
 export async function buildFileList(distDir) {
-    const relPaths = (await walk(distDir, distDir)).sort((a, b) => a.localeCompare(b));
+    const relPaths = (await walkFiles(distDir)).sort((a, b) => a.localeCompare(b));
     const files = [];
     for (const path of relPaths) {
         if (!isAllowedAsset(path)) {

package/dist/lib/base.d.ts

@@ -36,9 +36,11 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveAppsPath(override?: string): string;
     protected resolveFormPath(override?: string): string;
     protected resolveHooksPath(override?: string): string;
+    protected resolveMenuPath(override?: string): string;
     protected resolveOptionsPath(override?: string): string;
     protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
+    protected resolveThemeStylesPath(override?: string): string;
     private pickEnvironment;
     private resolveEnvironment;
     private resolveEnvironmentForConfiguredProject;

package/dist/lib/base.js

@@ -147,6 +147,9 @@ export class LoopressCommand extends Command {
     resolveHooksPath(override) {
         return resolveResourceDir('hooks', this.localConfig, override);
     }
+    resolveMenuPath(override) {
+        return resolveResourceDir('menu', this.localConfig, override);
+    }
     resolveOptionsPath(override) {
         return resolveResourceDir('options', this.localConfig, override);
     }
@@ -156,6 +159,9 @@ export class LoopressCommand extends Command {
     resolveSnippetsPath(override) {
         return resolveResourceDir('snippets', this.localConfig, override);
     }
+    resolveThemeStylesPath(override) {
+        return resolveResourceDir('themeStyles', this.localConfig, override);
+    }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];
         if (!env) {

package/dist/lib/find-orphaned-files.js

@@ -1,51 +1,9 @@
-import { readdir } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-// Same shape as load-files.ts's own walker, kept separate rather than shared: this one
-// filters against a list of extensions (snippet pull needs more than one), that one
-// against a single extension, and reconciling the two would cost more than the ~15 duplicated
-// lines it would save.
-async function walk(dir, extensions) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const relativePaths = [];
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            // join() builds the real OS path to actually walk, but the returned identity is always
-            // '/'-joined regardless of platform: it's matched against `keep`, filenames the server
-            // sends with '/', never the OS separator. join() here (backslash on Windows) would make
-            // every nested file's identity never match, findOrphanedFiles() would then report a
-            // live, kept file as orphaned and pull.ts would delete it.
-            const nested = await walk(join(dir, entry.name), extensions);
-            relativePaths.push(...nested.map((relativePath) => `${entry.name}/${relativePath}`));
-        }
-        else if (extensions.includes(extname(entry.name))) {
-            relativePaths.push(entry.name);
-        }
-    }
-    return relativePaths;
-}
+import { extname } from 'node:path';
+import { readdirTolerant, walkFiles } from './readdir-tolerant.js';
 export async function findOrphanedFiles(dir, keep, matcher) {
-    let files;
-    if (matcher.recursive) {
-        files = await walk(dir, matcher.extensions);
-    }
-    else {
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-    }
+    // walkFiles already returns '/'-joined identities regardless of platform: matched against
+    // `keep`, filenames the server sends with '/', never the OS separator.
+    const files = matcher.recursive ? await walkFiles(dir) : await readdirTolerant(dir);
     return files.filter((file) => {
         const ext = extname(file);
         if (!matcher.extensions.includes(ext))

package/dist/lib/load-files.js

@@ -1,52 +1,14 @@
-import { readdir, readFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
-// Recursion for the api resource type only (path-param route files can live in
-// subdirectories, e.g. api/invoice-pdf/[order_id].php); every other resource type stays
-// flat. withFileTypes avoids a second stat() per entry to tell files from directories.
-async function walk(dir, extension) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return [];
-        throw error;
-    }
-    const filePaths = [];
-    for (const entry of entries) {
-        const entryPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            filePaths.push(...(await walk(entryPath, extension)));
-        }
-        else if (extname(entry.name) === extension) {
-            filePaths.push(entryPath);
-        }
-    }
-    return filePaths;
-}
+import { readdirTolerant, walkFiles } from './readdir-tolerant.js';
 // Loads every `<extension>` file of a directory through `parse`. One file is read in
 // isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
 // only skip that file, never abort loading the rest of the directory, so `parse` throwing is
 // reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
 // "nothing to load", not an error.
 export async function loadFiles(dir, options) {
-    let filePaths;
-    if (options.recursive) {
-        filePaths = await walk(dir, options.extension);
-    }
-    else {
-        let entries;
-        try {
-            entries = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        filePaths = entries.filter((entry) => extname(entry) === options.extension).map((entry) => join(dir, entry));
-    }
+    const entries = options.recursive ? await walkFiles(dir) : await readdirTolerant(dir);
+    const filePaths = entries.filter((entry) => extname(entry) === options.extension).map((entry) => join(dir, entry));
     const items = [];
     for (const filePath of filePaths) {
         try {

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

@@ -29,6 +29,7 @@ type RemotePhpFile = {
     error?: string;
     filename: string;
     public?: boolean;
+    revision?: string;
 };
 type PushResult = {
     pruned: string[];

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

@@ -1,5 +1,6 @@
 import { confirm } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, sep } from 'node:path';
 import { authManager } from '../config/auth.manager.js';
@@ -11,12 +12,26 @@ import { basenameKey, findOrphanedFiles } from './find-orphaned-files.js';
 import { isInteractive } from './interactive.js';
 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';
 // 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
 // presence, so a file that would still fail server-side doesn't falsely pass this check.
 const DECLARE_PATTERN = /declare\s*\(\s*strict_types\s*=\s*1\s*\)\s*;/g;
+// A file's expected revision (#234), computed from `beforeState`: the remote listing already
+// read by `captureBeforePushState` right before this push, for the rollback snapshot. Its value
+// for a PHP file is exactly the file's own raw content string (see phpFilesProvider in
+// resource-state.ts), the same string AbstractFilesController::push_file() hashes server-side to
+// produce the `revision` it returns, so hashing it here the same way (sha256, hex) reproduces
+// that server revision with no extra network round trip and no need for the server to echo a
+// `revision` field back through the list endpoint for the CLI to consume. A filename absent from
+// `beforeState` (a new file, or `beforeState` itself unavailable, e.g. a dry run or a failed
+// remote read) has nothing to condition on: pushFile falls back to today's unconditional create.
+function expectedRevisionFor(beforeState, filename) {
+    const content = beforeState?.get(filename);
+    return typeof content === 'string' ? createHash('sha256').update(content, 'utf8').digest('hex') : undefined;
+}
 function pathArg(pathNoun) {
     return { path: Args.string({ description: `Path to ${pathNoun} (overrides project config)` }) };
 }
@@ -57,25 +72,34 @@ export function resourcePushCommand(spec) {
             const path = resolveResourceDir(spec.dirKind, this.localConfig, args.path);
             this.log(`Pushing ${spec.label} to ${url}`);
             this.log(`${spec.pathLabel} path: ${path}`);
+            const provider = getResourceStateProvider(spec.cliName);
+            const beforeState = await this.captureBeforePushState(provider, path);
             const files = await this.loadFiles(path);
             this.log(`Found ${pluralize(files.length, spec.noun)} to push`);
-            const pushed = [];
-            const publicRoutes = [];
+            // Local, network-free checks only (filename shape, the declare(strict_types=1) guard):
+            // catches a bad file before anything is staged on WordPress, same as before #236. The
+            // actual write is no longer per-file here, it's the single atomic batch request below.
             await this.runPushTasks(files, (file) => file.filename, async (file, task) => {
-                const result = await this.pushFile(file, task);
-                pushed.push(file.filename);
-                if (result?.public)
-                    publicRoutes.push(file.filename);
+                this.validateFileLocally(file, task);
             });
             if (this.failedCount > 0) {
                 this.error(`${pluralize(this.failedCount, spec.noun)} failed to push.`);
             }
-            for (const route of publicRoutes) {
-                this.warn(`${route}: PUBLIC route, no authentication required. Anyone on the internet can call it. See https://loopress.dev/api/routes/#authentication-and-permissions`);
+            // Resolved before the batch request: which files to prune is a local decision (a GET plus
+            // confirmation), but their removal itself happens inside the same atomic swap as the push
+            // below, not as separate DELETE calls, so a mid-push failure can't remove server-side
+            // files without also landing the new ones.
+            const pruneList = flags.prune ? await this.resolvePruneList(new Set(files.map((file) => file.filename))) : [];
+            if (this.dryRun) {
+                for (const file of files)
+                    this.log(`[dry-run] Would push: ${file.filename}`);
+                await this.writeAfterPushSnapshot(provider, path, beforeState);
+                return { pruned: pruneList, pushed: files.map((file) => file.filename), status: 'dry-run' };
             }
-            const pruned = flags.prune ? await this.prune(new Set(files.map((file) => file.filename))) : [];
-            if (this.dryRun)
-                return { pruned, pushed, status: 'dry-run' };
+            const { pruned, pushed } = files.length === 0 && pruneList.length === 0
+                ? { pruned: [], pushed: [] }
+                : await this.pushBatch(files, pruneList, beforeState);
+            await this.writeAfterPushSnapshot(provider, path, beforeState);
             await this.recordSuccess();
             await spec.afterPush?.({ filenames: pushed, siteConfig: this.siteConfig });
             this.log(`All ${spec.label} pushed.`);
@@ -84,12 +108,52 @@ export function resourcePushCommand(spec) {
         async loadFiles(path) {
             return loadPhpFiles(this, path);
         }
+        // One request stages every file and every pruned filename, then swaps them all into place
+        // together (#236): a failure anywhere in the batch (a stale expectedRevision, a class
+        // collision, a syntax error) leaves WordPress completely unchanged, not partially pushed.
+        async pushBatch(files, pruneList, beforeState) {
+            const body = {
+                files: files.map((file) => {
+                    const entry = { content: file.content, filename: file.filename };
+                    // `beforeState` was read once, at the start of this push run (see `expectedRevisionFor`
+                    // above): there is no per-file GET endpoint to re-read it right before this batch the
+                    // way `option push` does. Sent back as `expectedRevision`, WordPress still refuses the
+                    // whole batch (412) if something changed the file in between, instead of silently
+                    // overwriting it (#234); the vulnerable window is this run's own duration rather than a
+                    // single request's, wider than option's but still far smaller than not checking at all.
+                    const expectedRevision = expectedRevisionFor(beforeState, file.filename);
+                    if (expectedRevision !== undefined)
+                        entry.expectedRevision = expectedRevision;
+                    return entry;
+                }),
+                prune: pruneList,
+            };
+            let result;
+            try {
+                result = await this.wp.post(`${spec.endpoint}/batch`, body);
+            }
+            catch (error) {
+                this.error(`Push failed, nothing was changed on ${this.siteConfig.url}: ${error.message}`);
+            }
+            for (const file of result.files) {
+                this.log(file.syntax_check === 'skipped'
+                    ? `Pushed: ${file.filename} (syntax check skipped, unavailable on this host)`
+                    : `Pushed: ${file.filename}`);
+                if (file.public) {
+                    this.warn(`${file.filename}: PUBLIC route, no authentication required. Anyone on the internet can call it. See https://loopress.dev/api/routes/#authentication-and-permissions`);
+                }
+            }
+            for (const filename of result.pruned)
+                this.log(`Pruned: ${filename}`);
+            return { pruned: result.pruned, pushed: result.files.map((file) => file.filename) };
+        }
         // Mirror of `pull`'s local orphan cleanup, aimed at the server: any file on WordPress with
-        // no local counterpart is deleted. Opt-in (`--prune`) because it removes code from a live
-        // site. In a non-TTY without `--yes` it refuses rather than prunes: a stray local path in
-        // CI must not silently wipe production routes, and unlike `pull`'s local deletions these
-        // are not recoverable from the repo.
-        async prune(localFilenames) {
+        // no local counterpart is a candidate for removal. Opt-in (`--prune`) because it removes
+        // code from a live site. In a non-TTY without `--yes` it refuses rather than prunes: a stray
+        // local path in CI must not silently wipe production routes, and unlike `pull`'s local
+        // deletions these are not recoverable from the repo. Only decides *which* filenames to
+        // prune; pushBatch() is what actually removes them, atomically alongside the push.
+        async resolvePruneList(localFilenames) {
             const remote = await this.wp.get(spec.endpoint);
             const orphans = remote.map((file) => file.filename).filter((name) => !localFilenames.has(name));
             if (orphans.length === 0)
@@ -110,17 +174,9 @@ export function resourcePushCommand(spec) {
                     return [];
                 }
             }
-            // Sequential, like runPushTasks: keeps the "Pruned: …" lines ordered and the WordPress
-            // writes serial.
-            const deleted = [];
-            for (const filename of orphans) {
-                await this.wp.delete(`${spec.endpoint}?filename=${encodeURIComponent(filename)}`);
-                this.log(`Pruned: ${filename}`);
-                deleted.push(filename);
-            }
-            return deleted;
+            return orphans;
         }
-        async pushFile(file, task) {
+        validateFileLocally(file, task) {
             if (!spec.filenamePattern.test(file.filename)) {
                 const message = `Invalid filename "${file.filename}": ${spec.invalidFilenameHint}`;
                 this.reportTaskFailure(message, new Error(message), task);
@@ -131,27 +187,8 @@ export function resourcePushCommand(spec) {
                 const message = `${file.filename}.php: "declare(strict_types=1);" ${reason}, it must appear exactly once as the first statement`;
                 this.reportTaskFailure(message, new Error(message), task);
             }
-            if (this.dryRun) {
-                if (task)
-                    task.output = `[dry-run] Would push: ${file.filename}`;
-                return undefined;
-            }
-            try {
-                const result = await this.wp.put(spec.endpoint, {
-                    content: file.content,
-                    filename: file.filename,
-                });
-                if (task) {
-                    task.output =
-                        result.syntax_check === 'skipped'
-                            ? `Pushed: ${file.filename} (syntax check skipped, unavailable on this host)`
-                            : `Pushed: ${file.filename}`;
-                }
-                return result;
-            }
-            catch (error) {
-                this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);
-            }
+            if (task)
+                task.output = `Validated: ${file.filename}`;
         }
     }
     return ResourcePush;

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

@@ -1,7 +1,10 @@
 import { LoopressCommand } from './base.js';
+import { type ResourceState } from './diff-state.js';
+import { type ResourceStateProvider } from './resource-state.js';
 export declare abstract class PushCommand extends LoopressCommand {
     protected failedCount: number;
     private refusedByGuard;
+    protected captureBeforePushState(provider: ResourceStateProvider, dir: string): Promise<ResourceState | undefined>;
     catch(err: Error): Promise<void>;
     protected guardProductionPush(): Promise<void>;
     init(): Promise<void>;
@@ -13,4 +16,5 @@ export declare abstract class PushCommand extends LoopressCommand {
     protected runPushTasks<T>(items: T[], label: (item: T) => string, task: (item: T, task?: {
         output: string;
     }) => Promise<void>): Promise<void>;
+    protected writeAfterPushSnapshot(provider: ResourceStateProvider, dir: string, beforeState: ResourceState | undefined): Promise<void>;
 }

package/dist/lib/push-command.js

@@ -1,14 +1,35 @@
 import got from 'got';
 import { Listr } from 'listr2';
+import { resolve } from 'node:path';
 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';
 export class PushCommand extends LoopressCommand {
     failedCount = 0;
     // Refusals of the production guard never reach the site, so they must not pollute the
     // deployment history with failure records.
     refusedByGuard = false;
+    // Reads `provider`'s remote state right before a real push, for `writeAfterPushSnapshot` to
+    // pair with the actual post-push remote state once the push completes. A dry run changes
+    // nothing, so there is nothing to snapshot. Best-effort: a read failure (the site briefly
+    // unreachable) must never block the push itself, the same "never interrupt the push flow"
+    // stance recordDeployment takes; `undefined` tells `writeAfterPushSnapshot` there is no
+    // restore point to complete.
+    async captureBeforePushState(provider, dir) {
+        if (this.dryRun)
+            return undefined;
+        try {
+            return await provider.remote(this.wp, (message) => {
+                this.warn(message);
+            }, dir);
+        }
+        catch (error) {
+            this.warn(`Could not read remote state for a rollback snapshot: ${error.message}`);
+            return undefined;
+        }
+    }
     async catch(err) {
         if (!this.dryRun && !this.refusedByGuard && this.siteConfig) {
             await this.recordDeployment('failure');
@@ -73,4 +94,32 @@ export class PushCommand extends LoopressCommand {
             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
+    // 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.
+    async writeAfterPushSnapshot(provider, dir, beforeState) {
+        if (!beforeState || this.dryRun)
+            return;
+        try {
+            const afterState = await provider.remote(this.wp, (message) => {
+                this.warn(message);
+            }, dir);
+            await writeSnapshot({
+                afterState,
+                beforeState,
+                environment: this.siteConfig.name,
+                resource: provider.resource,
+                rootDir: resolve(process.cwd(), this.rootDir),
+            });
+        }
+        catch (error) {
+            this.warn(`Could not save a rollback snapshot after this push: ${error.message}`);
+        }
+    }
 }

package/dist/lib/readdir-tolerant.d.ts

@@ -4,3 +4,4 @@ export declare function readdirTolerant(dir: string, options: {
     recursive?: boolean;
     withFileTypes: true;
 }): Promise<Dirent[]>;
+export declare function walkFiles(dir: string): Promise<string[]>;

package/dist/lib/readdir-tolerant.js

@@ -1,4 +1,5 @@
 import { readdir } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
 export async function readdirTolerant(dir, options) {
     try {
         return options?.withFileTypes
@@ -11,3 +12,14 @@ export async function readdirTolerant(dir, options) {
         throw error;
     }
 }
+// Every file under `dir`, at any depth, as a path relative to `dir`. Always '/'-joined,
+// never the OS separator: callers match these identities against server-sent filenames
+// (which are always '/'-joined) or embed them in an API payload, so a Windows run must
+// produce the exact same strings as a POSIX one. ENOENT on `dir` itself yields no files,
+// same tolerance as readdirTolerant.
+export async function walkFiles(dir) {
+    const entries = await readdirTolerant(dir, { recursive: true, withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => relative(dir, join(entry.parentPath, entry.name)).split(sep).join('/'));
+}