@loopress/cli 0.32.1 → 0.33.0

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

@@ -5,7 +5,7 @@ export default class List extends LoopressCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<("taxonomies" | "field-groups" | "post-types" | "options-pages")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<Record<string, Array<Record<string, unknown>>>>;
 }

package/dist/commands/acf/list.js

@@ -7,17 +7,16 @@ export default class List extends LoopressCommand {
     static enableJsonFlag = true;
     static examples = ['$ lps acf list', '$ lps acf list --type field-groups'];
     static flags = {
-        type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
+        type: Flags.option({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES })(),
     };
     async run() {
         const { flags } = await this.parse(List);
-        const types = (flags.type && flags.type.length > 0 ? flags.type : ACF_OBJECT_TYPES);
+        const types = flags.type && flags.type.length > 0 ? flags.type : [...ACF_OBJECT_TYPES];
         const byType = {};
         for (const type of types) {
             byType[type] = await this.wp.get(acfEndpoint(type));
         }
-        for (const type of types) {
-            const objects = byType[type];
+        for (const [type, objects] of Object.entries(byType)) {
             this.log(`${type} (${objects.length}):`);
             if (objects.length === 0) {
                 this.log('  (none)');

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

@@ -14,7 +14,7 @@ export default class Pull extends LoopressCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<("taxonomies" | "field-groups" | "post-types" | "options-pages")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/acf/pull.js

@@ -15,13 +15,13 @@ export default class Pull extends LoopressCommand {
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,
-        type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
+        type: Flags.option({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES })(),
     };
     async run() {
         const { args, flags } = await this.parse(Pull);
         const { url } = this.siteConfig;
         const path = this.resolveAcfPath(args.path);
-        const types = (flags.type && flags.type.length > 0 ? flags.type : ACF_OBJECT_TYPES);
+        const types = flags.type && flags.type.length > 0 ? flags.type : [...ACF_OBJECT_TYPES];
         this.log(`Pulling ACF configuration from ${url}`);
         this.log(`ACF path: ${path}`);
         for (const type of types) {
@@ -32,12 +32,15 @@ export default class Pull extends LoopressCommand {
     async pullType(type, basePath) {
         const dir = join(basePath, type);
         const remoteList = await this.wp.get(acfEndpoint(type));
-        const withKey = remoteList.filter((object) => getAcfKey(object) !== null);
+        const withKey = remoteList.flatMap((object) => {
+            const key = getAcfKey(object);
+            return key === null ? [] : [{ key, object }];
+        });
         const skipped = remoteList.length - withKey.length;
         // Every file in a type's subdirectory is unambiguously `<key>.json`: `key` is the stable
         // identity ACF itself already uses (see its own Local JSON mechanism), no numeric-id/slug
         // filename convention like snippets.
-        const orphans = await findOrphanedFiles(dir, new Set(withKey.map((object) => getAcfKey(object))), {
+        const orphans = await findOrphanedFiles(dir, new Set(withKey.map(({ key }) => key)), {
             extensions: ['.json'],
             key: basenameKey,
         });
@@ -45,8 +48,8 @@ export default class Pull extends LoopressCommand {
             dryRunMessage: `Would pull ${withKey.length} ${type} to ${dir}`,
             orphanReason: `in ${dir} no longer present on WordPress`,
             pulledMessage: `Pulled ${withKey.length} ${type} to ${dir}`,
-            title: (object) => getAcfKey(object),
-            write: async (object, writeDir) => writeFile(join(writeDir, `${getAcfKey(object)}.json`), JSON.stringify(object, null, 2) + '\n'),
+            title: ({ key }) => key,
+            write: async ({ key, object }, writeDir) => writeFile(join(writeDir, `${key}.json`), JSON.stringify(object, null, 2) + '\n'),
         });
         if (this.dryRun)
             return;

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

@@ -18,7 +18,7 @@ export default class Push extends PushCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<("taxonomies" | "field-groups" | "post-types" | "options-pages")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/acf/push.js

@@ -1,6 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { join } from 'node:path';
 import { loadFiles } from '../../lib/load-files.js';
+import { errorMessage, isRecord } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
@@ -17,13 +18,13 @@ export default class Push extends PushCommand {
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,
-        type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
+        type: Flags.option({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES })(),
     };
     async run() {
         const { args, flags } = await this.parse(Push);
         const { url } = this.siteConfig;
         const path = this.resolveAcfPath(args.path);
-        const types = (flags.type && flags.type.length > 0 ? flags.type : ACF_OBJECT_TYPES);
+        const types = flags.type && flags.type.length > 0 ? flags.type : [...ACF_OBJECT_TYPES];
         this.log(`Pushing ACF configuration to ${url}`);
         this.log(`ACF path: ${path}`);
         const provider = getResourceStateProvider('acf');
@@ -66,7 +67,7 @@ export default class Push extends PushCommand {
             onSkip: (message) => { this.warn(message); },
             parse(raw) {
                 const parsed = JSON.parse(raw);
-                if (typeof parsed !== 'object' || parsed === null || getAcfKey(parsed) === null) {
+                if (!isRecord(parsed) || getAcfKey(parsed) === null) {
                     throw new Error('missing or invalid "key"');
                 }
                 return parsed;
@@ -96,7 +97,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${key}`;
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${key}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${key}: ${errorMessage(error)}`, error, task);
         }
     }
     async pushType(type, basePath) {

package/dist/commands/api/publish.js

@@ -2,6 +2,7 @@ import { Args, Command } from '@oclif/core';
 import { basename, join } from 'node:path';
 import { ApiClient } from '../../lib/api-client.js';
 import { loadFiles } from '../../lib/load-files.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { resolveLinkedProject } from '../../lib/resolve-linked-project.js';
 import { pluralize } from '../../utils/pluralize.js';
 // Publishes to the Loopress api (not a WordPress site), so this does not extend
@@ -37,7 +38,7 @@ export default class Publish extends Command {
             });
         }
         catch (error) {
-            this.error(error.message);
+            this.error(errorMessage(error));
         }
         this.log(`Published ${pluralize(files.length, 'route')} to your Loopress account.`);
     }

package/dist/commands/app/pull.js

@@ -7,6 +7,7 @@ import { dirname, join } from 'node:path';
 import { APP_CONFIG_FILENAME, parseAppConfig } from '../../lib/app-manifest.js';
 import { LoopressCommand } from '../../lib/base.js';
 import { isInteractive } from '../../lib/interactive.js';
+import { errorCode } from '../../lib/narrow.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Pull extends LoopressCommand {
     static args = {
@@ -49,7 +50,7 @@ export default class Pull extends LoopressCommand {
             entries = await readdir(path, { withFileTypes: true });
         }
         catch (error) {
-            if (error.code === 'ENOENT')
+            if (errorCode(error) === 'ENOENT')
                 return [];
             throw error;
         }

package/dist/commands/app/push.js

@@ -4,6 +4,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildApp } from '../../lib/app-build.js';
 import { APP_CONFIG_FILENAME, diffFiles, loadAppManifest, } from '../../lib/app-manifest.js';
+import { errorCode, errorMessage } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { pluralize } from '../../utils/pluralize.js';
@@ -54,7 +55,7 @@ export default class Push extends PushCommand {
             entries = await readdir(path, { withFileTypes: true });
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
+            if (errorCode(error) === 'ENOENT') {
                 this.error(`Apps directory not found: ${path}. Create ${join(path, '<name>', APP_CONFIG_FILENAME)} first.`);
             }
             throw error;
@@ -90,7 +91,7 @@ export default class Push extends PushCommand {
             ({ distDir, manifest } = await loadAppManifest(appDir, dirName));
         }
         catch (error) {
-            this.reportTaskFailure(`${dirName}: ${error.message}`, error, task);
+            this.reportTaskFailure(`${dirName}: ${errorMessage(error)}`, error, task);
         }
         const remote = await this.remoteFiles(manifest.name);
         const changed = diffFiles(manifest.files, remote);
@@ -113,7 +114,7 @@ export default class Push extends PushCommand {
             committed = await this.wp.post(`loopress/v1/apps/${manifest.name}/commit`, manifest);
         }
         catch (error) {
-            this.reportTaskFailure(`${manifest.name}: commit failed: ${error.message}`, error, task);
+            this.reportTaskFailure(`${manifest.name}: commit failed: ${errorMessage(error)}`, error, task);
         }
         this.warnIfCrossOriginIgnored(manifest, committed);
         if (task) {
@@ -141,7 +142,7 @@ export default class Push extends PushCommand {
             await this.wp.put(`loopress/v1/apps/${name}/assets`, { content, encoding: 'base64', path: file.path });
         }
         catch (error) {
-            this.reportTaskFailure(`${name}: failed to upload ${file.path}: ${error.message}`, error);
+            this.reportTaskFailure(`${name}: failed to upload ${file.path}: ${errorMessage(error)}`, error);
         }
     }
     // An older plugin, or an app .htaccess the site owner manages, commits the build without the

package/dist/commands/app/{remove.d.ts → rm.d.ts}

@@ -5,6 +5,7 @@ type RemoveResult = {
     status: 'aborted' | 'dry-run' | 'success';
 };
 export default class Remove extends LoopressCommand {
+    static aliases: string[];
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };

package/dist/commands/app/{remove.js → rm.js}

@@ -4,12 +4,13 @@ import { LoopressCommand } from '../../lib/base.js';
 import { guardProductionPush } from '../../lib/guard-production-push.js';
 import { isInteractive } from '../../lib/interactive.js';
 export default class Remove extends LoopressCommand {
+    static aliases = ['app:remove'];
     static args = {
         name: Args.string({ description: 'App to remove from WordPress', required: true }),
     };
     static description = 'Remove a single-page app from WordPress: deletes its bundle from wp-content/loopress/apps/ and unregisters the shortcode. Local files are left untouched.';
     static enableJsonFlag = true;
-    static examples = ['$ lps app remove search'];
+    static examples = ['$ lps app rm search'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,

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

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

package/dist/commands/block/diff.js

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

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

@@ -0,0 +1,8 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { type RemoteBlock } from '../../utils/block-format.js';
+export default class List extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<RemoteBlock[]>;
+}

package/dist/commands/block/list.js

@@ -0,0 +1,23 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { BLOCKS_ENDPOINT } from '../../utils/block-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class List extends LoopressCommand {
+    static description = 'List the dynamic blocks Loopress registers on WordPress (loopress/<slug>), with their load and render errors';
+    static enableJsonFlag = true;
+    static examples = ['$ lps block list'];
+    async run() {
+        const blocks = await this.wp.get(BLOCKS_ENDPOINT);
+        if (blocks.length === 0) {
+            this.log('No dynamic blocks found');
+            return blocks;
+        }
+        this.log(`Found ${pluralize(blocks.length, 'block')}:`);
+        for (const block of blocks) {
+            const notRegistered = block.error ? `  not registered: ${block.error}` : '';
+            this.log(`  loopress/${block.slug}  (${Object.keys(block.files).join(', ')})${notRegistered}`);
+            if (block.runtimeError)
+                this.log(`    render.php threw, last at ${block.runtimeError.at}: ${block.runtimeError.message}`);
+        }
+        return blocks;
+    }
+}

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

@@ -0,0 +1,21 @@
+import { LoopressCommand } from '../../lib/base.js';
+type PullResult = {
+    orphans: string[];
+    pulled: string[];
+    status: 'dry-run' | 'success';
+};
+export default class Pull extends LoopressCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<PullResult>;
+    private removeOrphanBlocks;
+}
+export {};

package/dist/commands/block/pull.js

@@ -0,0 +1,67 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { errorMessage } from '../../lib/narrow.js';
+import { assertSafeBlock, BLOCKS_ENDPOINT, readLocalBlocks, writeBlock } from '../../utils/block-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to blocks directory (overrides project config)' }),
+    };
+    static description = 'Pull the dynamic blocks Loopress registers on WordPress into blocks/<slug>/ folders';
+    static enableJsonFlag = true;
+    static examples = ['$ lps block pull'];
+    static flags = { ...LoopressCommand.dryRunFlag, ...LoopressCommand.yesFlag };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const path = resolveResourceDir('block', this.localConfig, args.path);
+        this.log(`Pulling dynamic blocks from ${this.siteConfig.url}`);
+        this.log(`Blocks path: ${path}`);
+        const remote = await this.wp.get(BLOCKS_ENDPOINT);
+        // All of them before the first rm() below, so a bad entry never costs a good local block.
+        try {
+            for (const block of remote)
+                assertSafeBlock(block);
+        }
+        catch (error) {
+            this.error(errorMessage(error));
+        }
+        const remoteSlugs = new Set(remote.map((block) => block.slug));
+        const orphans = (await readLocalBlocks(path)).blocks.map((block) => block.slug).filter((slug) => !remoteSlugs.has(slug));
+        const pulled = remote.map((block) => block.slug);
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${pluralize(remote.length, 'block')} to ${path}`);
+            if (orphans.length > 0)
+                this.log(`[dry-run] Would remove ${pluralize(orphans.length, 'local block')} no longer on WordPress: ${orphans.join(', ')}`);
+            return { orphans, pulled, status: 'dry-run' };
+        }
+        for (const block of remote) {
+            // Replaced as a whole, like on the site: a file dropped there is dropped here too.
+            await rm(join(path, block.slug), { force: true, recursive: true });
+            await writeBlock(path, { files: block.files, slug: block.slug });
+        }
+        await this.removeOrphanBlocks(path, orphans);
+        this.log(`Pulled ${pluralize(remote.length, 'block')} to ${path}`);
+        return { orphans, pulled, status: 'success' };
+    }
+    // Same confirmation rules as removeOrphanedFiles, for folders.
+    async removeOrphanBlocks(path, orphans) {
+        if (orphans.length === 0)
+            return;
+        const description = `${pluralize(orphans.length, 'local block')} no longer on WordPress: ${orphans.join(', ')}`;
+        if (!this.yes && isInteractive() && !(await confirm({ default: true, message: `Remove ${description}?` }))) {
+            this.log(`Kept ${description}`);
+            return;
+        }
+        for (const slug of orphans)
+            await rm(join(path, slug), { force: true, recursive: true });
+        if (this.yes || isInteractive())
+            this.log(`Removed ${description}`);
+        else
+            this.warn(`Removed ${description}`);
+    }
+}

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

@@ -0,0 +1,20 @@
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    changes?: PushChange[];
+    pushed: string[];
+    status: 'dry-run' | 'success';
+};
+export default class Push extends PushCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<PushResult>;
+}
+export {};

package/dist/commands/block/push.js

@@ -0,0 +1,48 @@
+import { Args } from '@oclif/core';
+import { isDeepStrictEqual } from 'node:util';
+import { errorMessage } from '../../lib/narrow.js';
+import { PushCommand } from '../../lib/push-command.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { BLOCKS_ENDPOINT, formatBlockProblems, readLocalBlocks } from '../../utils/block-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to blocks directory (overrides project config)' }),
+    };
+    static description = 'Push local dynamic blocks (blocks/<slug>/ holding block.json, render.php, and optionally style.css and view.js) to WordPress, ' +
+        'registered as loopress/<slug> and placed with <!-- wp:loopress/<slug> /-->. Each block is replaced as a whole. Create or update only, never deletes a block (use `lps block rm`).';
+    static enableJsonFlag = true;
+    static examples = ['$ lps block push', '$ lps block push --dry-run'];
+    static flags = { ...PushCommand.dryRunFlag, ...PushCommand.yesFlag };
+    async run() {
+        const { args } = await this.parse(Push);
+        const path = resolveResourceDir('block', this.localConfig, args.path);
+        this.log(`Pushing dynamic blocks to ${this.siteConfig.url}`);
+        this.log(`Blocks path: ${path}`);
+        const { blocks, problems } = await readLocalBlocks(path);
+        if (problems.length > 0)
+            this.error(formatBlockProblems(problems));
+        this.log(`Found ${pluralize(blocks.length, 'block')} to push`);
+        const provider = getResourceStateProvider('block');
+        const beforeState = await this.captureBeforePushState(provider, path);
+        if (this.dryRun)
+            return { changes: this.previewChanges, pushed: blocks.map((block) => block.slug), status: 'dry-run' };
+        // Unchanged blocks are skipped: each one is a write of its whole folder.
+        const changed = blocks.filter((block) => !isDeepStrictEqual(beforeState?.get(block.slug), block.files));
+        await this.runPushTasks(changed, (block) => `loopress/${block.slug}`, async (block, task) => {
+            try {
+                await this.wp.put(BLOCKS_ENDPOINT, { files: block.files, slug: block.slug });
+            }
+            catch (error) {
+                this.reportTaskFailure(`${block.slug}: ${errorMessage(error)}`, error, task);
+            }
+        });
+        if (this.failedCount > 0)
+            this.error(`${pluralize(this.failedCount, 'block')} failed to push.`);
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
+        await this.recordSuccess();
+        this.log(changed.length === 0 ? 'All blocks already up to date.' : 'All blocks pushed.');
+        return { pushed: changed.map((block) => block.slug), status: 'success' };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RmResult = {
+    references: string[];
+    removed: boolean;
+    slug: string;
+    status: 'aborted' | 'dry-run' | 'success';
+};
+export default class Rm extends LoopressCommand {
+    static aliases: string[];
+    static args: {
+        slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<RmResult>;
+    private localReferences;
+}
+export {};

package/dist/commands/block/rm.js

@@ -0,0 +1,69 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { readdirTolerant } from '../../lib/readdir-tolerant.js';
+import { isApplicative404 } from '../../lib/wp-client.js';
+import { BLOCK_SLUG, BLOCKS_ENDPOINT } from '../../utils/block-format.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
+export default class Rm extends LoopressCommand {
+    static aliases = ['block:remove'];
+    static args = {
+        slug: Args.string({ description: 'The block to remove, its blocks/ folder name (e.g. "hero")', required: true }),
+    };
+    static description = 'Remove a dynamic block from WordPress. A <!-- wp:loopress/<slug> /--> left in a page or template renders nothing until it is pushed again. Local files are left untouched.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps block rm hero', '$ lps block rm hero --yes'];
+    static flags = { ...LoopressCommand.dryRunFlag, ...LoopressCommand.yesFlag };
+    async run() {
+        const { args } = await this.parse(Rm);
+        const { slug } = args;
+        const { url } = this.siteConfig;
+        if (!BLOCK_SLUG.test(slug))
+            this.error(`Invalid block slug "${slug}": lowercase letters, digits and hyphens, starting with a letter.`);
+        const references = await this.localReferences(slug);
+        if (references.length > 0) {
+            this.warn(`loopress/${slug} is still used in ${references.join(', ')}: it will render nothing there.`);
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would remove loopress/${slug} from ${url}`);
+            return { references, removed: false, slug, status: 'dry-run' };
+        }
+        if (!this.yes) {
+            if (!isInteractive())
+                this.error(`Removing loopress/${slug} needs confirmation. Re-run with --yes.`);
+            if (!(await confirm({ default: false, message: `Remove loopress/${slug} from ${url}?` }))) {
+                this.log('Aborted.');
+                return { references, removed: false, slug, status: 'aborted' };
+            }
+        }
+        try {
+            await this.wp.delete(`${BLOCKS_ENDPOINT}?slug=${encodeURIComponent(slug)}`);
+        }
+        catch (error) {
+            if (isApplicative404(error, `Unknown block "${slug}"`))
+                this.error(`loopress/${slug} is not on ${url}.`);
+            throw error;
+        }
+        this.log(`Removed loopress/${slug} from ${url}`);
+        return { references, removed: true, slug, status: 'success' };
+    }
+    // The project's own files still placing the block: pages, templates, parts and patterns.
+    async localReferences(slug) {
+        const marker = new RegExp(String.raw `<!--\s*wp:loopress/${slug}[\s/]`);
+        const found = [];
+        for (const kind of ['page', 'template', 'part', 'pattern']) {
+            const dir = resolveResourceDir(kind, this.localConfig);
+            for (const entry of await readdirTolerant(dir, { recursive: true, withFileTypes: true })) {
+                if (!entry.isFile() || !entry.name.endsWith('.html'))
+                    continue;
+                const file = join(entry.parentPath, entry.name);
+                if (marker.test(await readFile(file, 'utf8')))
+                    found.push(relative(process.cwd(), file));
+            }
+        }
+        return found;
+    }
+}

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

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

package/dist/commands/block/rollback.js

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

package/dist/commands/composer/init.js

@@ -4,6 +4,7 @@ import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
 import { isInteractive } from '../../lib/interactive.js';
+import {} from '../../utils/composer.js';
 const WPACKAGIST_REPOSITORY = { type: 'composer', url: 'https://wpackagist.org' };
 const INSTALLERS_PACKAGE = 'composer/installers';
 const INSTALLERS_CONSTRAINT = '^2.0';

package/dist/commands/composer/push.js

@@ -3,9 +3,10 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { confirmUninstall } from '../../lib/interactive.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isLocalEnvironment, isTimeoutError } from '../../lib/wp-client.js';
-import { requireToInstall, toIntent } from '../../utils/composer.js';
+import { parseComposerJson, requireToInstall, toIntent } from '../../utils/composer.js';
 import { parseCollisions, SYNC_TIMEOUT_MS, } from '../../utils/plugin-sync.js';
 export default class ComposerPush extends PushCommand {
     static description = 'Push composer.json to WordPress and run Composer to resolve and install dependencies';
@@ -25,7 +26,7 @@ export default class ComposerPush extends PushCommand {
         if (!existsSync(composerJsonPath)) {
             this.error(`No composer.json found at ${composerJsonPath}. Run \`lps composer init\` first.`);
         }
-        const parsed = JSON.parse(await readFile(composerJsonPath, 'utf8'));
+        const parsed = parseComposerJson(await readFile(composerJsonPath, 'utf8'));
         const require = requireToInstall(parsed, isLocalEnvironment(this.siteConfig.name));
         const packageCount = Object.keys(require).length;
         const intent = toIntent(require);
@@ -57,7 +58,7 @@ export default class ComposerPush extends PushCommand {
                 this.error('Plugins or themes are installed outside Loopress. Re-run with --force to take them over.');
             }
             if (isTimeoutError(error)) {
-                this.error(`${error.message} The Composer run may still be in progress on the server.`);
+                this.error(`${errorMessage(error)} The Composer run may still be in progress on the server.`);
             }
             throw error;
         }
@@ -84,7 +85,7 @@ export default class ComposerPush extends PushCommand {
     }
     async wpackagistToRemove(require) {
         const { composerJson } = await this.wp.get('loopress/v1/composer/json');
-        const current = JSON.parse(composerJson).require ?? {};
+        const current = parseComposerJson(composerJson).require ?? {};
         return Object.keys(current).filter((name) => name.startsWith('wpackagist-') && !Object.hasOwn(require, name));
     }
 }

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

@@ -22,7 +22,10 @@ export default class Copy extends LoopressCommand {
     };
     run(): Promise<ContentCopyResult>;
     protected sourceWp(from: string): WpClient;
+    private alignPlugins;
+    private alignTheme;
     private confirmReplace;
     private copy;
+    private readAlignment;
 }
 export {};