@loopress/cli 0.24.0 → 0.25.0

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

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

package/dist/commands/acf/push.js

@@ -2,7 +2,9 @@ import { Args, Flags } from '@oclif/core';
 import { join } from 'node:path';
 import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
-import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { ACF_OBJECT_TYPES, acfEndpoint, acfObjectEndpoint, getAcfKey } from '../../utils/acf-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
     static args = {
@@ -22,9 +24,12 @@ export default class Push extends PushCommand {
         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');
+        const beforeState = await this.captureBeforePushState(provider, path);
         for (const type of types) {
             await this.pushType(type, path);
         }
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'ACF object')} failed to push.`);
         }
@@ -33,6 +38,17 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         this.log('All ACF objects pushed.');
     }
+    async currentRevision(type, key) {
+        try {
+            const current = await this.wp.get(acfObjectEndpoint(type, key));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     async loadObjects(dir) {
         return loadFiles(dir, {
             extension: '.json',
@@ -57,7 +73,14 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.post(acfEndpoint(type), object);
+            // Read the object's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // object in between, instead of this push silently overwriting it (#234). No revision to
+            // condition on for an object that doesn't exist remotely yet (a first push, an upsert
+            // create): falls back to today's unconditional write, same as before this existed.
+            const expectedRevision = await this.currentRevision(type, key);
+            const body = expectedRevision === undefined ? object : { ...object, expectedRevision };
+            await this.wp.post(acfEndpoint(type), body);
             if (task)
                 task.output = `Pushed: ${key}`;
         }

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

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

package/dist/commands/acf/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('acf', {
+    description: 'Restore ACF field groups, post types, taxonomies, and options pages to a snapshot taken automatically before an earlier `lps acf push`',
+    pathNoun: 'ACF directory',
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").RmFilesCommand>;
+export default _default;

package/dist/commands/api/rm.js

@@ -0,0 +1,2 @@
+import { API_FILES_RESOURCE, resourceRmCommand } from '../../lib/php-files-command.js';
+export default resourceRmCommand(API_FILES_RESOURCE);

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

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

package/dist/commands/api/rollback.js

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

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

@@ -1,6 +1,8 @@
 import { PushCommand } from '../../lib/push-command.js';
+import { type LockDriftEntry } from '../../utils/plugin-sync.js';
 type PushResult = {
     hasLock: boolean;
+    lockDrift: LockDriftEntry[];
     packageCount: number;
     status: 'dry-run' | 'success';
 };
@@ -14,5 +16,6 @@ export default class ComposerPush extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private reportLockDrift;
 }
 export {};

package/dist/commands/composer/push.js

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { isTimeoutError } from '../../lib/wp-client.js';
-import { parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
+import { parseCollisions, SYNC_TIMEOUT_MS, } from '../../utils/plugin-sync.js';
 // Split a composer.json `require` map into the three intent namespaces the sync endpoint
 // understands. `composer/installers` is owned by the server scaffold, never sent.
 function toIntent(require) {
@@ -25,7 +25,7 @@ function toIntent(require) {
     return intent;
 }
 export default class ComposerPush extends PushCommand {
-    static description = 'Push composer.json (and composer.lock, if present) to WordPress and run Composer';
+    static description = 'Push composer.json to WordPress and run Composer to resolve and install dependencies';
     static enableJsonFlag = true;
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
@@ -47,14 +47,16 @@ export default class ComposerPush extends PushCommand {
         const packageCount = Object.keys(require).length;
         const intent = toIntent(require);
         const hasLock = existsSync(composerLockPath);
+        // The server resolves composer.json itself; it never installs from this lock (a crafted
+        // lock could point package downloads at arbitrary hosts). It is sent only so the server
+        // can report which pinned versions its own resolution moved. `lps composer pull` brings
+        // the resolved lock back.
         const lock = hasLock ? await readFile(composerLockPath, 'utf8') : null;
         this.log(`Pushing composer.json (${packageCount} ${packageCount === 1 ? 'package' : 'packages'}) to ${url}`);
         if (lock)
-            this.log('  + composer.lock included (reproducible install)');
-        else
-            this.warn('No composer.lock found. The server will resolve versions freely.');
+            this.log('  + composer.lock sent for drift comparison (the server resolves versions from composer.json)');
         if (this.dryRun)
-            return { hasLock, packageCount, status: 'dry-run' };
+            return { hasLock, lockDrift: [], packageCount, status: 'dry-run' };
         this.log('Running Composer on the server, this can take a few minutes...');
         let response;
         try {
@@ -72,7 +74,22 @@ export default class ComposerPush extends PushCommand {
         if (response.output.trim())
             this.log(response.output.trim());
         this.log('Composer run completed on the server.');
+        const lockDrift = response.lockDrift ?? [];
+        this.reportLockDrift(lockDrift);
         await this.recordSuccess();
-        return { hasLock, packageCount, status: 'success' };
+        return { hasLock, lockDrift, packageCount, status: 'success' };
+    }
+    // The server resolves composer.json from scratch and never installs from the uploaded lock,
+    // so a project that committed a lock can see versions move. Spell out exactly what changed
+    // and point at `lps composer pull` to bring the resolved lock back locally.
+    reportLockDrift(lockDrift) {
+        if (lockDrift.length === 0)
+            return;
+        this.log('');
+        this.log(`The server resolved ${lockDrift.length} ${lockDrift.length === 1 ? 'package' : 'packages'} to a different version than your local composer.lock:`);
+        for (const { from, name, to } of lockDrift) {
+            this.log(`  ${name}: ${from ?? '(absent)'} -> ${to ?? '(removed)'}`);
+        }
+        this.log('Run `lps composer pull` to update your local composer.json and composer.lock.');
     }
 }

package/dist/commands/diff.js

@@ -7,7 +7,7 @@ const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resour
 export default class Diff extends DiffCommand {
     static description = [
         'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
-        'Covers snippets, forms, ACF, API routes, Hooks, SEO, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Covers snippets, forms, ACF, API routes, Hooks, SEO, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
         'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
     ].join(' ');
     static enableJsonFlag = true;

package/dist/commands/doctor.d.ts

@@ -1,8 +1,24 @@
 import { LoopressCommand } from '../lib/base.js';
+export type DoctorCheck = {
+    message?: string;
+    ok: boolean;
+    title: string;
+};
+export type DoctorResult = {
+    checks: DoctorCheck[];
+    environment: string;
+    ok: boolean;
+    pluginVersion?: string;
+    project: string;
+    url: string;
+};
 export default class Doctor extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
-    run(): Promise<void>;
+    private readonly checks;
+    run(): Promise<DoctorResult>;
     private check;
+    private out;
     private reportPluginVersion;
 }

package/dist/commands/doctor.js

@@ -5,76 +5,93 @@ import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
 import { pluralize } from '../utils/pluralize.js';
 export default class Doctor extends LoopressCommand {
     static description = 'Diagnose connectivity, plugin and credential problems for the targeted environment';
+    static enableJsonFlag = true;
     static examples = ['$ lps doctor', '$ lps doctor --env production'];
+    checks = [];
     async run() {
         const { name, token, url } = this.siteConfig;
         const project = this.localConfig.projectId
             ? configManager.getProject(this.localConfig.projectId)
             : configManager.getCurrentProject();
-        this.log(`Project:      ${project?.name ?? '(unknown)'}`);
-        this.log(`Environment:  ${name}`);
-        this.log(`URL:          ${url}`);
-        this.log('');
-        let failed = 0;
+        const projectName = project?.name ?? '(unknown)';
+        this.out(`Project:      ${projectName}`);
+        this.out(`Environment:  ${name}`);
+        this.out(`URL:          ${url}`);
+        this.out('');
+        let pluginVersion;
         const isReachable = await this.check('WordPress REST API reachable', async () => {
             const diagnostic = await diagnoseWpSite(url);
             if (!diagnostic.ok)
                 throw new Error(diagnostic.reason);
         });
-        if (!isReachable) {
-            failed++;
-            this.log('- Remaining checks skipped while the site is unreachable.');
-            this.error('1 check failed.', { exit: 1 });
-        }
-        if (!token) {
-            this.log('✗ Credentials configured');
-            this.log(`  No credentials stored for ${url}. Run \`lps project config\` to add them.`);
-            this.log('- Remaining checks skipped without credentials.');
-            this.error('1 check failed.', { exit: 1 });
-        }
-        // The namespace index answers regardless of which Loopress features are active, so a 404
-        // here can only mean the plugin itself is missing or outdated (WpClient's 404 message
-        // already says exactly that).
-        if (!(await this.check('Loopress plugin installed (loopress/v1 endpoints)', async () => this.wp.get('loopress/v1')))) {
-            failed++;
-        }
-        // wp/v2/users/me is WordPress core and requires authentication, so it validates the
-        // application password without depending on any Loopress feature.
-        if (!(await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me')))) {
-            failed++;
+        if (isReachable) {
+            if (token) {
+                // The namespace index answers regardless of which Loopress features are active, so a
+                // 404 here can only mean the plugin itself is missing or outdated (WpClient's 404
+                // message already says exactly that).
+                await this.check('Loopress plugin installed (loopress/v1 endpoints)', async () => this.wp.get('loopress/v1'));
+                // wp/v2/users/me is WordPress core and requires authentication, so it validates the
+                // application password without depending on any Loopress feature.
+                await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me'));
+                pluginVersion = await this.reportPluginVersion();
+            }
+            else {
+                this.checks.push({
+                    message: `No credentials stored for ${url}. Run \`lps project config\` to add them.`,
+                    ok: false,
+                    title: 'Credentials configured',
+                });
+                this.out('✗ Credentials configured');
+                this.out(`  No credentials stored for ${url}. Run \`lps project config\` to add them.`);
+                this.out('- Remaining checks skipped without credentials.');
+            }
         }
-        await this.reportPluginVersion();
-        this.log('');
-        if (failed > 0) {
-            this.error(`${pluralize(failed, 'check')} failed.`, { exit: 1 });
+        else {
+            this.out('- Remaining checks skipped while the site is unreachable.');
         }
-        this.log('All checks passed.');
+        const failed = this.checks.filter((check) => !check.ok).length;
+        const ok = failed === 0;
+        this.out('');
+        this.out(ok ? 'All checks passed.' : `${pluralize(failed, 'check')} failed.`);
+        if (!ok)
+            process.exitCode = 1;
+        return { checks: this.checks, environment: name, ok, pluginVersion, project: projectName, url };
     }
     async check(title, run) {
         try {
             await run();
-            this.log(`✓ ${title}`);
+            this.checks.push({ ok: true, title });
+            this.out(`✓ ${title}`);
             return true;
         }
         catch (error) {
-            this.log(`✗ ${title}`);
-            this.log(`  ${error.message}`);
+            const { message } = error;
+            this.checks.push({ message, ok: false, title });
+            this.out(`✗ ${title}`);
+            this.out(`  ${message}`);
             return false;
         }
     }
+    out(message) {
+        if (!this.jsonEnabled())
+            this.log(message);
+    }
     // Informational only: Loopress Light does not expose loopress/v1/update, and an old plugin
     // predates it, neither should flip the doctor to a failure when everything else works.
     async reportPluginVersion() {
         try {
             const status = await this.wp.get('loopress/v1/update');
-            this.log(`✓ Plugin version: ${status.current_version ?? '(unknown)'}`);
+            const version = status.current_version ?? '(unknown)';
+            this.out(`✓ Plugin version: ${version}`);
+            return version;
         }
         catch (error) {
             if (isNotFoundError(error)) {
-                this.log('- Plugin version: not exposed by this plugin edition.');
-                return;
+                this.out('- Plugin version: not exposed by this plugin edition.');
+                return undefined;
             }
-            this.log(`- Plugin version: could not be read. ${error.message}`);
+            this.out(`- Plugin version: could not be read. ${error.message}`);
+            return undefined;
         }
     }
 }

package/dist/commands/form/pull.js

@@ -39,7 +39,10 @@ export default class Pull extends LoopressCommand {
             async write(form, writeDir) {
                 const id = getFormId(form);
                 const title = getFormTitle(form);
-                await writeFile(join(writeDir, `${id}-${toSlug(title, 'untitled')}.json`), JSON.stringify(form, null, 2) + '\n');
+                // `revision` is server bookkeeping (see RemoteForm in form-format.ts), never part of
+                // the tracked configuration: never persisted locally.
+                const local = Object.fromEntries(Object.entries(form).filter(([key]) => key !== 'revision'));
+                await writeFile(join(writeDir, `${id}-${toSlug(title, 'untitled')}.json`), JSON.stringify(local, null, 2) + '\n');
             },
         });
         if (this.dryRun)

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

@@ -6,10 +6,13 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'allow-notifications': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    private allowNotifications;
     run(): Promise<void>;
+    private currentRevision;
     private ensureCanonicalFilename;
     private loadFiles;
     private pushForm;

package/dist/commands/form/push.js

@@ -1,10 +1,12 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { readFile, rename } from 'node:fs/promises';
 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 { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { FORM_ENDPOINT, formEndpoint, getFormId, getFormTitle } from '../../utils/form-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends PushCommand {
@@ -12,20 +14,29 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
     };
     static description = 'Push forms to WordPress. Local files created or updated remotely are renamed on disk to the `<id>-<slug>.json` convention.';
-    static examples = ['$ lps form push'];
+    static examples = ['$ lps form push', '$ lps form push --allow-notifications'];
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,
+        'allow-notifications': Flags.boolean({
+            default: false,
+            description: "Also push each form's notification and confirmation settings (recipients, sender, messages). Off by default: the server keeps its own so a stray push can't redirect submissions.",
+        }),
     };
+    allowNotifications = false;
     async run() {
-        const { args } = await this.parse(Push);
+        const { args, flags } = await this.parse(Push);
         const { url } = this.siteConfig;
         const path = this.resolveFormPath(args.path);
+        this.allowNotifications = flags['allow-notifications'];
         this.log(`Pushing forms to ${url}`);
         this.log(`Forms path: ${path}`);
+        const provider = getResourceStateProvider('form');
+        const beforeState = await this.captureBeforePushState(provider, path);
         const files = await this.loadFiles(path);
         this.log(`Found ${pluralize(files.length, 'form')} to push`);
         await this.runPushTasks(files, ({ data }) => getFormTitle(data), async ({ data, filePath }, task) => this.pushForm(filePath, data, task));
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'form')} failed to push.`);
         }
@@ -34,6 +45,17 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         this.log('All forms pushed.');
     }
+    async currentRevision(id) {
+        try {
+            const current = await this.wp.get(formEndpoint(id));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     // Renames the local file to the `<id>-<slug>.json` convention used by `form pull`
     // whenever it doesn't already match (a hand-created file with no id, or a stale slug after
     // a title change in the WordPress admin), same principle as ensureCanonicalFilename in
@@ -78,11 +100,22 @@ export default class Push extends PushCommand {
         }
         try {
             const id = getFormId(data);
+            const payload = this.allowNotifications ? { ...data, allowNotifications: true } : data;
+            // Read the form's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // form in between, instead of this push silently overwriting it (#234). No revision to
+            // condition on for a form that doesn't exist remotely yet (a first push, or one whose id
+            // 404s below and falls back to create): that PUT attempt just 404s too, same as before
+            // this existed. Kept out of the POST fallback body (`postPayload`): it is a precondition
+            // on an existing resource, meaningless (and never persisted) on a freshly created one.
+            const expectedRevision = id === null ? undefined : await this.currentRevision(id);
+            const putPayload = expectedRevision === undefined ? payload : { ...payload, expectedRevision };
             const { body, created } = await putOrCreate(this.wp, {
                 id,
-                payload: data,
+                payload: putPayload,
                 postEndpoint: FORM_ENDPOINT,
-                putEndpoint: (formId) => `${FORM_ENDPOINT}/${formId}`,
+                postPayload: payload,
+                putEndpoint: formEndpoint,
             });
             const canonicalId = created ? getFormId(body) : id;
             if (canonicalId !== null)

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

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

package/dist/commands/form/rollback.js

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

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/php-files-command.js").RmFilesCommand>;
+export default _default;

package/dist/commands/hook/rm.js

@@ -0,0 +1,2 @@
+import { HOOK_FILES_RESOURCE, resourceRmCommand } from '../../lib/php-files-command.js';
+export default resourceRmCommand(HOOK_FILES_RESOURCE);

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

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

package/dist/commands/hook/rollback.js

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

package/dist/commands/init.js

@@ -15,6 +15,7 @@ const SNIPPET_PROVIDERS = [
 const FEATURES = [
     { dir: 'acf', key: 'acfDir', label: 'ACF' },
     { dir: 'seo', key: 'seoDir', label: 'SEO' },
+    { dir: 'menus', key: 'menuDir', label: 'Menus' },
     { dir: 'forms', key: 'formDir', label: 'Forms' },
     { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
     { dir: 'hooks', key: 'hooksDir', label: 'Hooks (actions, filters, cron)' },

package/dist/commands/login.js

@@ -13,8 +13,9 @@ export default class Login extends Command {
     }
     async waitForCallback() {
         return waitForLocalCallback({
-            buildUrl(callbackBaseUrl) {
-                const callbackUrl = encodeURIComponent(`${callbackBaseUrl}/callback`);
+            allowedOrigins: [CONSOLE_URL],
+            buildUrl(callbackBaseUrl, state) {
+                const callbackUrl = encodeURIComponent(`${callbackBaseUrl}/callback?state=${state}`);
                 return `${CONSOLE_URL}/cli-auth?callbackUrl=${callbackUrl}`;
             },
             handleRequest(url, { resolveWithPage, respondBadRequest }) {

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

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

package/dist/commands/menu/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('menu', {
+    description: 'Show what differs in nav menus and the active theme menu locations between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'menus directory',
+});

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

@@ -0,0 +1,13 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { type Menu, type MenuLocations } from '../../utils/menu-format.js';
+type ListResult = {
+    locations: MenuLocations;
+    menus: Menu[];
+};
+export default class List extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<ListResult>;
+}
+export {};

package/dist/commands/menu/list.js

@@ -0,0 +1,32 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../../utils/menu-format.js';
+function countItems(items) {
+    return items.reduce((total, item) => total + 1 + countItems(item.children), 0);
+}
+export default class List extends LoopressCommand {
+    static description = 'List nav menus and the active theme menu locations on WordPress';
+    static enableJsonFlag = true;
+    static examples = ['$ lps menu list'];
+    async run() {
+        const menus = await this.wp.get(MENU_ENDPOINT);
+        const locations = await this.wp.get(MENU_LOCATIONS_ENDPOINT);
+        if (menus.length === 0) {
+            this.log('(no menus)');
+        }
+        for (const menu of menus) {
+            this.log(`${menu.slug} (${menu.name}): ${countItems(menu.items)} item(s)`);
+            for (const warning of menu.warnings)
+                this.warn(`${menu.slug}: ${warning}`);
+        }
+        this.log('');
+        this.log('locations:');
+        const entries = Object.entries(locations);
+        if (entries.length === 0) {
+            this.log('  (none registered by the active theme)');
+        }
+        for (const [location, slug] of entries) {
+            this.log(`  ${location}: ${slug ?? '(unassigned)'}`);
+        }
+        return { locations, menus };
+    }
+}

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

@@ -0,0 +1,15 @@
+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: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private pullLocations;
+    private pullMenus;
+}