@loopress/cli 0.17.0 → 0.19.0

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

@@ -7,9 +7,9 @@ export default class Pull extends LoopressCommand {
     static examples: string[];
     static flags: {
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private findOrphanedFiles;
     private pullType;
 }

package/dist/commands/acf/pull.js

@@ -1,8 +1,9 @@
 import { Args, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
-import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class Pull extends LoopressCommand {
     static args = {
@@ -12,6 +13,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps acf pull', '$ lps acf pull --type field-groups'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
     async run() {
@@ -25,28 +27,18 @@ export default class Pull extends LoopressCommand {
             await this.pullType(type, path);
         }
     }
-    // Every file in a type's subdirectory is unambiguously `<key>.json` — unlike snippets, ACF
-    // objects have no numeric-id/slug filename convention. `key` is the stable identity ACF
-    // itself already uses for this (see its own Local JSON mechanism), so orphan detection is a
-    // plain set difference, no regex/extension juggling needed.
-    async findOrphanedFiles(dir, keepKeys) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        return files.filter((file) => extname(file) === '.json' && !keepKeys.has(file.slice(0, -'.json'.length)));
-    }
     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 skipped = remoteList.length - withKey.length;
-        const orphans = await this.findOrphanedFiles(dir, new Set(withKey.map((object) => getAcfKey(object))));
+        // 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))), {
+            extensions: ['.json'],
+            key: basenameKey,
+        });
         if (this.dryRun) {
             this.log(`[dry-run] Would pull ${withKey.length} ${type} to ${dir}`);
             if (orphans.length > 0) {
@@ -66,12 +58,7 @@ export default class Pull extends LoopressCommand {
                 title: `Pull ${key}`,
             };
         })).run();
-        for (const file of orphans) {
-            await rm(join(dir, file), { force: true });
-        }
-        if (orphans.length > 0) {
-            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
-        }
+        await this.removeOrphanedFiles(dir, orphans, `in ${dir} no longer present on WordPress`);
         this.log(`Pulled ${withKey.length} ${type} to ${dir}`);
         if (skipped > 0) {
             this.warn(`${skipped} ${type} skipped because they have no key`);

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

@@ -7,9 +7,9 @@ export default class Push extends PushCommand {
     static examples: string[];
     static flags: {
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<void>;
     private loadObjects;
     private pushObject;

package/dist/commands/acf/push.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+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';
 export default class Push extends PushCommand {
@@ -12,9 +12,9 @@ export default class Push extends PushCommand {
     static examples = ['$ lps acf push', '$ lps acf push --type field-groups'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
-    failedCount = 0;
     async run() {
         const { args, flags } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -33,45 +33,22 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         this.log('All ACF objects pushed.');
     }
-    // One object's file is read in isolation: a corrupted or hand-broken JSON file (or one
-    // missing/emptying its "key") must only skip that object, not abort loading the rest of
-    // the type's directory — same principle as loadSnippets() for the snippet feature.
     async loadObjects(dir) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        const objects = [];
-        for (const file of files) {
-            if (extname(file) !== '.json')
-                continue;
-            const filePath = join(dir, file);
-            let parsed;
-            try {
-                parsed = JSON.parse(await readFile(filePath, 'utf8'));
-            }
-            catch (error) {
-                this.warn(`Skipping "${filePath}": ${error.message}`);
-                continue;
-            }
-            if (typeof parsed !== 'object' || parsed === null || getAcfKey(parsed) === null) {
-                this.warn(`Skipping "${filePath}": missing or invalid "key"`);
-                continue;
-            }
-            objects.push(parsed);
-        }
-        return objects;
+        return loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => this.warn(message),
+            parse(raw) {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed !== 'object' || parsed === null || getAcfKey(parsed) === null) {
+                    throw new Error('missing or invalid "key"');
+                }
+                return parsed;
+            },
+        });
     }
-    // Throwing on failure (rather than returning a boolean) is what lets Listr mark the task as
-    // failed (red cross) instead of completed; `exitOnError: false` on the task list still lets
-    // sibling objects push regardless. POST alone covers create-or-update (the controller resolves
-    // that server-side via the object's `key`), unlike snippet push there's no numeric-id PUT/404
-    // fallback dance, and no rename-on-push step since `key` is permanently stable.
+    // POST alone covers create-or-update (the controller resolves that server-side via the
+    // object's `key`), unlike snippet push there's no numeric-id PUT/404 fallback dance, and no
+    // rename-on-push step since `key` is permanently stable.
     async pushObject(type, object, task) {
         const key = getAcfKey(object) ?? '(unknown)';
         if (this.dryRun) {
@@ -85,13 +62,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${key}`;
         }
         catch (error) {
-            const message = `Failed to push ${key}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${key}: ${error.message}`, error, task);
         }
     }
     async pushType(type, basePath) {

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

@@ -0,0 +1,9 @@
+import { LoopressCommand } from '../../lib/base.js';
+export default class List extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/api/list.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+export default class List extends LoopressCommand {
+    static description = 'List custom API route files from WordPress';
+    static examples = ['$ lps api list'];
+    static flags = {
+        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const files = await this.wp.get('loopress/v1/api-files');
+        if (flags.json) {
+            this.log(JSON.stringify(files, null, 2));
+            return;
+        }
+        if (files.length === 0) {
+            this.log('No API route files found');
+            return;
+        }
+        this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'}:`);
+        this.log('');
+        for (const file of files) {
+            this.log(`  ${file.filename}`);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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>;
+}

package/dist/commands/api/pull.js

@@ -0,0 +1,49 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to api directory (overrides project config)' }),
+    };
+    static description = 'Pull custom API route files from WordPress';
+    static examples = ['$ lps api pull', '$ lps api pull --path ./api'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolveApiPath(args.path);
+        this.log(`Pulling API routes from ${url}`);
+        this.log(`API path: ${path}`);
+        const files = await this.wp.get('loopress/v1/api-files');
+        // A `<filename>.php` no longer present remotely belongs to a route deleted on WordPress
+        // (push itself stays additive-only, but pull already cleans up locally, same as
+        // `snippet pull`).
+        const orphans = await findOrphanedFiles(path, new Set(files.map((file) => file.filename)), {
+            extensions: ['.php'],
+            key: basenameKey,
+        });
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} whose route no longer exists on WordPress: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        await mkdir(path, { recursive: true });
+        await new Listr(files.map((file) => ({
+            async task(_ctx, task) {
+                await writeFile(join(path, `${file.filename}.php`), file.content);
+                task.output = `Pulled: ${file.filename}`;
+            },
+            title: `Pull ${file.filename}`,
+        }))).run();
+        await this.removeOrphanedFiles(path, orphans, 'whose route no longer exists on WordPress');
+        this.log(`Pulled ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
+    }
+}

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

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

package/dist/commands/api/push.js

@@ -0,0 +1,70 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { basename } from 'node:path';
+import { loadFiles as loadDirectoryFiles } from '../../lib/load-files.js';
+import { PushCommand } from '../../lib/push-command.js';
+// Mirrors the server's own allowlist (wordpress-plugin ApiFilesController::FILENAME_PATTERN):
+// the filename becomes a URL path segment matched against this exact regex by the WP REST
+// route itself. A filename that doesn't match never reaches the controller, WordPress's
+// router returns a generic 404 before validate_callback runs, which the CLI's shared error
+// formatter reports as "is the plugin installed?", a confusing message for what is actually
+// an invalid filename. Checking client-side first turns that into an accurate error and
+// skips a network round-trip that could only ever fail.
+const FILENAME_PATTERN = /^[a-z0-9-]+$/;
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to api directory (overrides project config)' }),
+    };
+    static description = 'Push custom API route files to WordPress';
+    static examples = ['$ lps api push', '$ lps api push --path ./api'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveApiPath(args.path);
+        this.log(`Pushing API routes to ${url}`);
+        this.log(`API path: ${path}`);
+        const files = await this.loadFiles(path);
+        this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'} to push`);
+        await new Listr(files.map((file) => ({
+            task: async (_ctx, task) => this.pushFile(file, task),
+            title: `Push ${file.filename}`,
+        })), { concurrent: false, exitOnError: false }).run();
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} route file${this.failedCount === 1 ? '' : 's'} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All API routes pushed.');
+    }
+    async loadFiles(path) {
+        return loadDirectoryFiles(path, {
+            extension: '.php',
+            onSkip: (message) => this.warn(message),
+            parse: (raw, filePath) => ({ content: raw, filename: basename(filePath, '.php') }),
+        });
+    }
+    async pushFile(file, task) {
+        if (!FILENAME_PATTERN.test(file.filename)) {
+            const message = `Invalid filename "${file.filename}": only lowercase letters, digits, and hyphens are allowed (e.g. "hello-world.php")`;
+            this.reportTaskFailure(message, new Error(message), task);
+        }
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${file.filename}`;
+            return;
+        }
+        try {
+            await this.wp.put(`loopress/v1/api-files/${file.filename}`, { content: file.content });
+            if (task)
+                task.output = `Pushed: ${file.filename}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);
+        }
+    }
+}

package/dist/commands/composer/init.js

@@ -3,11 +3,12 @@ import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
 const WPACKAGIST_REPOSITORY = { type: 'composer', url: 'https://wpackagist.org' };
 const INSTALLERS_PACKAGE = 'composer/installers';
 const INSTALLERS_CONSTRAINT = '^2.0';
 // The server runs Composer with `--working-dir` set to wp-content/loopress/ (see
-// LoopressEnvironment::getDxDir), not the WordPress root, so installer-paths must climb out
+// LoopressEnvironment::getLoopressDir), not the WordPress root, so installer-paths must climb out
 // of that directory to land plugins/themes in their usual wp-content/ locations.
 const INSTALLER_PATHS = {
     '../plugins/{$name}/': ['type:wordpress-plugin'],
@@ -22,6 +23,10 @@ export default class ComposerInit extends LoopressCommand {
     async run() {
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         if (existsSync(composerJsonPath)) {
+            if (!isInteractive()) {
+                this.log('composer.json already exists, not overwriting (non-interactive terminal).');
+                return;
+            }
             const overwrite = await confirm({ default: false, message: 'composer.json already exists. Overwrite?' });
             if (!overwrite) {
                 this.log('Aborted.');
@@ -29,6 +34,11 @@ export default class ComposerInit extends LoopressCommand {
             }
         }
         const composerJson = {
+            // composer/installers is itself a Composer plugin, and Composer 2.2+ refuses to run any
+            // plugin that isn't explicitly trusted when running non-interactively (which every
+            // `composer push` on the server does). Without this, the very first real push against
+            // this scaffold 500s on Composer's own plugin-trust gate before ever touching a package.
+            config: { 'allow-plugins': { [INSTALLERS_PACKAGE]: true } },
             extra: { 'installer-paths': INSTALLER_PATHS },
             name: 'loopress/site-dependencies',
             repositories: [WPACKAGIST_REPOSITORY],

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

@@ -3,6 +3,7 @@ export default class ComposerPush extends PushCommand {
     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>;

package/dist/commands/composer/push.js

@@ -2,11 +2,15 @@ import { existsSync } from 'node:fs';
 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';
+// A cold composer install easily exceeds the global 30s timeout of WpClient.
+const COMPOSER_SYNC_TIMEOUT_MS = 600_000;
 export default class ComposerPush extends PushCommand {
     static description = 'Push composer.json and composer.lock to WordPress and run composer install';
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
     async run() {
         const { url } = this.siteConfig;
@@ -29,10 +33,19 @@ export default class ComposerPush extends PushCommand {
         }
         if (this.dryRun)
             return;
-        await this.wp.post('loopress/v1/composer/sync', {
-            composerJson: composerJsonRaw,
-            composerLock: composerLockRaw,
-        });
+        this.log('Running composer install on the server, this can take a few minutes...');
+        try {
+            await this.wp.post('loopress/v1/composer/sync', {
+                composerJson: composerJsonRaw,
+                composerLock: composerLockRaw,
+            }, { timeoutMs: COMPOSER_SYNC_TIMEOUT_MS });
+        }
+        catch (error) {
+            if (isTimeoutError(error)) {
+                this.error(`${error.message} The composer install may still be running on the server.`);
+            }
+            throw error;
+        }
         this.log('composer install completed on the server.');
         await this.recordSuccess();
     }

package/dist/commands/doctor.d.ts

@@ -0,0 +1,8 @@
+import { LoopressCommand } from '../lib/base.js';
+export default class Doctor extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private check;
+    private reportPluginVersion;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,79 @@
+import { configManager } from '../config/project-config.manager.js';
+import { LoopressCommand } from '../lib/base.js';
+import { isNotFoundError } from '../lib/wp-client.js';
+import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
+export default class Doctor extends LoopressCommand {
+    static description = 'Diagnose connectivity, plugin and credential problems for the targeted environment';
+    static examples = ['$ lps doctor', '$ lps doctor --env production'];
+    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 reachable = await this.check('WordPress REST API reachable', async () => {
+            const diagnostic = await diagnoseWpSite(url);
+            if (!diagnostic.ok)
+                throw new Error(diagnostic.reason);
+        });
+        if (!reachable) {
+            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)', () => 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)', () => this.wp.get('wp/v2/users/me')))) {
+            failed++;
+        }
+        await this.reportPluginVersion();
+        this.log('');
+        if (failed > 0) {
+            this.error(`${failed} check${failed === 1 ? '' : 's'} failed.`, { exit: 1 });
+        }
+        this.log('All checks passed.');
+    }
+    async check(title, run) {
+        try {
+            await run();
+            this.log(`✓ ${title}`);
+            return true;
+        }
+        catch (error) {
+            this.log(`✗ ${title}`);
+            this.log(`  ${error.message}`);
+            return false;
+        }
+    }
+    // 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)'}`);
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                this.log('- Plugin version: not exposed by this plugin edition.');
+                return;
+            }
+            this.log(`- Plugin version: could not be read. ${error.message}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { LoopressCommand } from '../../lib/base.js';
+export default class List extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/form/list.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
+export default class List extends LoopressCommand {
+    static description = 'List forms from WordPress';
+    static examples = ['$ lps form list'];
+    static flags = {
+        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const forms = await this.wp.get(FORM_ENDPOINT);
+        if (flags.json) {
+            this.log(JSON.stringify(forms, null, 2));
+            return;
+        }
+        this.log(`Forms (${forms.length}):`);
+        if (forms.length === 0) {
+            this.log('  (none)');
+            return;
+        }
+        for (const form of forms) {
+            this.log(`  ${getFormId(form) ?? '(no id)'}. ${getFormTitle(form)}`);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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>;
+}