@loopress/cli 0.24.1 → 0.26.0

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;

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/dev-watch.d.ts

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'plugins' | 'snippets';
+export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
 export declare const RESOURCE_TYPES: ResourceType[];
 export type WatchTarget = {
     commandId: string;

package/dist/lib/dev-watch.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
-export const RESOURCE_TYPES = ['snippets', 'api', 'plugins'];
+export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
 // `only` narrows the default set, `skip` then removes from whatever that set is, same
 // precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
 export function resolveResourceTypes(only, skip = []) {
@@ -15,6 +15,7 @@ export function buildWatchTargets(types, localConfig, cwd) {
     const rootDir = join(cwd, localConfig.rootDir ?? '.');
     const candidates = {
         api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
         plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
         snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
     };

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[];