@loopress/cli 0.20.1 → 0.22.0

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

@@ -1,10 +1,10 @@
 import { LoopressCommand } from '../../lib/base.js';
 export default class List extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<Record<string, Array<Record<string, unknown>>>>;
 }

package/dist/commands/acf/list.js

@@ -3,9 +3,9 @@ import { LoopressCommand } from '../../lib/base.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class List extends LoopressCommand {
     static description = 'List ACF field groups, post types, taxonomies, and options pages from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps acf list', '$ lps acf list --type field-groups'];
     static flags = {
-        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
     async run() {
@@ -15,10 +15,6 @@ export default class List extends LoopressCommand {
         for (const type of types) {
             byType[type] = await this.wp.get(acfEndpoint(type));
         }
-        if (flags.json) {
-            this.log(JSON.stringify(byType, null, 2));
-            return;
-        }
         for (const type of types) {
             const objects = byType[type];
             this.log(`${type} (${objects.length}):`);
@@ -28,9 +24,11 @@ export default class List extends LoopressCommand {
                 continue;
             }
             for (const object of objects) {
-                this.log(`  ${getAcfKey(object) ?? '(no key)'}. ${String(object.title ?? '(untitled)')}`);
+                const title = typeof object.title === 'string' ? object.title : '(untitled)';
+                this.log(`  ${getAcfKey(object) ?? '(no key)'}. ${title}`);
             }
             this.log('');
         }
+        return byType;
     }
 }

package/dist/commands/acf/pull.js

@@ -1,6 +1,5 @@
 import { Args, Flags } from '@oclif/core';
-import { Listr } from 'listr2';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { 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';
@@ -39,27 +38,15 @@ export default class Pull extends LoopressCommand {
             extensions: ['.json'],
             key: basenameKey,
         });
-        if (this.dryRun) {
-            this.log(`[dry-run] Would pull ${withKey.length} ${type} to ${dir}`);
-            if (orphans.length > 0) {
-                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
-            }
+        await this.pullDirectory(dir, withKey, orphans, {
+            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'),
+        });
+        if (this.dryRun)
             return;
-        }
-        if (withKey.length > 0)
-            await mkdir(dir, { recursive: true });
-        await new Listr(withKey.map((object) => {
-            const key = getAcfKey(object);
-            return {
-                async task(_ctx, task) {
-                    await writeFile(join(dir, `${key}.json`), JSON.stringify(object, null, 2) + '\n');
-                    task.output = `Pulled: ${key}`;
-                },
-                title: `Pull ${key}`,
-            };
-        })).run();
-        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.js

@@ -1,9 +1,9 @@
 import { Args, Flags } from '@oclif/core';
-import { Listr } from 'listr2';
 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 { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to ACF directory (overrides project config)' }),
@@ -26,7 +26,7 @@ export default class Push extends PushCommand {
             await this.pushType(type, path);
         }
         if (this.failedCount > 0) {
-            this.error(`${this.failedCount} ACF object${this.failedCount === 1 ? '' : 's'} failed to push.`);
+            this.error(`${pluralize(this.failedCount, 'ACF object')} failed to push.`);
         }
         if (this.dryRun)
             return;
@@ -36,7 +36,7 @@ export default class Push extends PushCommand {
     async loadObjects(dir) {
         return loadFiles(dir, {
             extension: '.json',
-            onSkip: (message) => this.warn(message),
+            onSkip: (message) => { this.warn(message); },
             parse(raw) {
                 const parsed = JSON.parse(raw);
                 if (typeof parsed !== 'object' || parsed === null || getAcfKey(parsed) === null) {
@@ -71,9 +71,6 @@ export default class Push extends PushCommand {
         if (objects.length === 0)
             return;
         this.log(`Found ${objects.length} ${type} to push`);
-        await new Listr(objects.map((object) => ({
-            task: async (_ctx, task) => this.pushObject(type, object, task),
-            title: `Push ${getAcfKey(object) ?? '(unknown)'}`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await this.runPushTasks(objects, (object) => getAcfKey(object) ?? '(unknown)', async (object, task) => this.pushObject(type, object, task));
     }
 }

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

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

package/dist/commands/api/list.js

@@ -1,26 +1,20 @@
-import { Flags } from '@oclif/core';
 import { LoopressCommand } from '../../lib/base.js';
+import { pluralize } from '../../utils/pluralize.js';
 export default class List extends LoopressCommand {
     static description = 'List custom API route files from WordPress';
+    static enableJsonFlag = true;
     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;
+            return files;
         }
-        this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'}:`);
+        this.log(`Found ${pluralize(files.length, 'route file')}:`);
         this.log('');
         for (const file of files) {
             this.log(`  ${file.filename}`);
         }
+        return files;
     }
 }

package/dist/commands/api/publish.js

@@ -1,10 +1,9 @@
 import { Args, Command } from '@oclif/core';
 import { basename, join } from 'node:path';
-import { authManager } from '../../config/auth.manager.js';
-import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 import { loadFiles } from '../../lib/load-files.js';
-import { readLocalConfig } from '../../utils/loopress-config.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
 // `LoopressCommand`/`PushCommand`: those force an environment to be resolved, but publishing
 // for cross-project sharing doesn't need one, same reasoning as `snippet publish`. An API route
@@ -20,41 +19,26 @@ export default class Publish extends Command {
     static examples = ['$ lps api publish', '$ lps api publish --path ./api'];
     async run() {
         const { args } = await this.parse(Publish);
-        const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token;
-        if (!token) {
-            this.error('Not logged in. Run `lps login` first.');
-        }
-        const localConfig = await readLocalConfig();
-        const projectId = localConfig.projectId ?? configManager.getCurrentProject()?.id;
-        if (!projectId) {
-            this.error('No project configured. Run `lps project config` first.');
-        }
-        const project = configManager.getProject(projectId);
-        if (!project) {
-            this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
-        }
-        if (!project.apiProjectId) {
-            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project push\` first.`);
-        }
+        const { apiProjectId, localConfig, token } = await resolveLinkedProject((message) => this.error(message));
         const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.apiDir ?? 'api');
         this.log(`Publishing API routes from ${path}`);
         const files = await loadFiles(path, {
             extension: '.php',
-            onSkip: (message) => this.warn(message),
+            onSkip: (message) => { this.warn(message); },
             parse: (raw, filePath) => ({ code: raw, filename: basename(filePath, '.php') }),
         });
         const api = new ApiClient(token);
         try {
-            await api.post(`projects/${project.apiProjectId}/api-routes/publish/upsert`, {
+            await api.post(`projects/${apiProjectId}/api-routes/publish/upsert`, {
                 routes: files,
             });
-            await api.post(`projects/${project.apiProjectId}/api-routes/publish/prune`, {
+            await api.post(`projects/${apiProjectId}/api-routes/publish/prune`, {
                 filenames: files.map((file) => file.filename),
             });
         }
         catch (error) {
             this.error(error.message);
         }
-        this.log(`Published ${files.length} route${files.length === 1 ? '' : 's'} to your Loopress account.`);
+        this.log(`Published ${pluralize(files.length, 'route')} to your Loopress account.`);
     }
 }

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

@@ -1,13 +1,20 @@
 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<void>;
+    run(): Promise<PullResult>;
 }
+export {};

package/dist/commands/api/pull.js

@@ -1,14 +1,15 @@
 import { Args } from '@oclif/core';
-import { Listr } from 'listr2';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
 import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
+import { pluralize } from '../../utils/pluralize.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 enableJsonFlag = true;
     static examples = ['$ lps api pull', '$ lps api pull --path ./api'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -27,23 +28,26 @@ export default class Pull extends LoopressCommand {
         const orphans = await findOrphanedFiles(path, new Set(files.map((file) => file.filename)), {
             extensions: ['.php'],
             key: basenameKey,
+            recursive: true,
         });
-        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}`;
+        const pulled = files.map((file) => file.filename);
+        await this.pullDirectory(path, files, orphans, {
+            alwaysCreateDir: true,
+            dryRunMessage: `Would pull ${pluralize(files.length, 'route file')} to ${path}`,
+            orphanReason: 'whose route no longer exists on WordPress',
+            pulledMessage: `Pulled ${pluralize(files.length, 'route file')} to ${path}`,
+            title: (file) => file.filename,
+            async write(file, writeDir) {
+                const filePath = join(writeDir, `${file.filename}.php`);
+                // filename can contain '/' (a path-param route, e.g. invoice-pdf/[order_id]):
+                // writeFile() doesn't create parent directories on its own the way mkdir()'s
+                // recursive option does above for the top-level path.
+                await mkdir(dirname(filePath), { recursive: true });
+                await writeFile(filePath, file.content);
             },
-            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}`);
+        });
+        if (this.dryRun)
+            return { orphans, pulled, status: 'dry-run' };
+        return { orphans, pulled, status: 'success' };
     }
 }

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

@@ -1,16 +1,22 @@
 import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    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<void>;
+    run(): Promise<PushResult>;
     private loadFiles;
     private pushFile;
     private syncApiRoutes;
 }
+export {};

package/dist/commands/api/push.js

@@ -1,23 +1,29 @@
 import { Args } from '@oclif/core';
-import { Listr } from 'listr2';
-import { basename } from 'node:path';
+import { relative, sep } from 'node:path';
 import { authManager } from '../../config/auth.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 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-]+$/;
+import { pluralize } from '../../utils/pluralize.js';
+// Mirrors the server's own allowlist (wordpress-plugin ApiFilesController::isValidFilename()):
+// filename is sent as a body param (not a URL path segment: a nested path can contain '/' and
+// '[]', and depending on a server to handle a percent-encoded slash in a URL path correctly is
+// exactly the kind of hosting-environment variance Loopress can't assume away), but validating
+// client-side first still turns a malformed name into an accurate error and skips a network
+// round-trip that could only ever fail.
+const FILENAME_PATTERN = /^(?:[a-z0-9-]+|\[[A-Za-z_]\w*\])(?:\/(?:[a-z0-9-]+|\[[A-Za-z_]\w*\]))*$/;
+// Mirrors the server's own check (wordpress-plugin FileWriter::DECLARE_PATTERN /
+// withGuard()): the server rejects both an absent declare(strict_types=1); and one that
+// appears more than once (it needs a single unambiguous insertion point for the ABSPATH
+// guard). Matching that "exactly once" rule here too, not just presence, so a file that
+// would still fail server-side doesn't falsely pass this earlier check.
+const DECLARE_PATTERN = /declare\s*\(\s*strict_types\s*=\s*1\s*\)\s*;/g;
 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 enableJsonFlag = true;
     static examples = ['$ lps api push', '$ lps api push --path ./api'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -30,30 +36,44 @@ export default class Push extends PushCommand {
         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();
+        this.log(`Found ${pluralize(files.length, 'route file')} to push`);
+        const pushed = [];
+        await this.runPushTasks(files, (file) => file.filename, async (file, task) => {
+            await this.pushFile(file, task);
+            pushed.push(file.filename);
+        });
         if (this.failedCount > 0) {
-            this.error(`${this.failedCount} route file${this.failedCount === 1 ? '' : 's'} failed to push.`);
+            this.error(`${pluralize(this.failedCount, 'route file')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { pushed, status: 'dry-run' };
         await this.recordSuccess();
         await this.syncApiRoutes(files.map((file) => file.filename));
         this.log('All API routes pushed.');
+        return { pushed, status: 'success' };
     }
     async loadFiles(path) {
         return loadDirectoryFiles(path, {
             extension: '.php',
-            onSkip: (message) => this.warn(message),
-            parse: (raw, filePath) => ({ content: raw, filename: basename(filePath, '.php') }),
+            onSkip: (message) => { this.warn(message); },
+            // relative()'s separator is OS-specific ('\\' on Windows); the server only ever expects
+            // '/', same as any URL or import path.
+            parse: (raw, filePath) => ({
+                content: raw,
+                filename: relative(path, filePath).slice(0, -'.php'.length).split(sep).join('/'),
+            }),
+            recursive: true,
         });
     }
     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")`;
+            const message = `Invalid filename "${file.filename}": each path segment must be lowercase letters, digits, and hyphens, or a bracketed dynamic segment like "[order_id]" (e.g. "invoice-pdf/[order_id].php")`;
+            this.reportTaskFailure(message, new Error(message), task);
+        }
+        const declareCount = file.content.match(DECLARE_PATTERN)?.length ?? 0;
+        if (declareCount !== 1) {
+            const reason = declareCount === 0 ? 'is missing' : 'appears more than once';
+            const message = `${file.filename}.php: "declare(strict_types=1);" ${reason}, it must appear exactly once as the first statement`;
             this.reportTaskFailure(message, new Error(message), task);
         }
         if (this.dryRun) {
@@ -62,9 +82,16 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.put(`loopress/v1/api-files/${file.filename}`, { content: file.content });
-            if (task)
-                task.output = `Pushed: ${file.filename}`;
+            const result = await this.wp.put('loopress/v1/api-files', {
+                content: file.content,
+                filename: file.filename,
+            });
+            if (task) {
+                task.output =
+                    result.syntax_check === 'skipped'
+                        ? `Pushed: ${file.filename} (syntax check skipped, unavailable on this host)`
+                        : `Pushed: ${file.filename}`;
+            }
         }
         catch (error) {
             this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);

package/dist/commands/composer/init.js

@@ -27,12 +27,16 @@ export default class ComposerInit extends LoopressCommand {
                 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) {
+            const isOverwrite = await confirm({ default: false, message: 'composer.json already exists. Overwrite?' });
+            if (!isOverwrite) {
                 this.log('Aborted.');
                 return;
             }
         }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would write composer.json to ${composerJsonPath}`);
+            return;
+        }
         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
@@ -46,10 +50,6 @@ export default class ComposerInit extends LoopressCommand {
                 [INSTALLERS_PACKAGE]: INSTALLERS_CONSTRAINT,
             },
         };
-        if (this.dryRun) {
-            this.log(`[dry-run] Would write composer.json to ${composerJsonPath}`);
-            return;
-        }
         await writeFile(composerJsonPath, JSON.stringify(composerJson, null, 2) + '\n', 'utf8');
         this.log(`Wrote composer.json to ${composerJsonPath}`);
         this.log('Add plugins with `wpackagist-plugin/<slug>` and a theme with `wpackagist-theme/<slug>` in require, then run `lps composer push`.');

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

@@ -1,9 +1,15 @@
 import { LoopressCommand } from '../../lib/base.js';
+type PullResult = {
+    status: 'dry-run' | 'success';
+    wroteLock: boolean;
+};
 export default class ComposerPull extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<PullResult>;
 }
+export {};

package/dist/commands/composer/pull.js

@@ -21,6 +21,7 @@ function isMissingComposerLock(error) {
 }
 export default class ComposerPull extends LoopressCommand {
     static description = 'Pull composer.json and composer.lock from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps composer pull', '$ lps composer pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -45,16 +46,17 @@ export default class ComposerPull extends LoopressCommand {
         }
         if (this.dryRun) {
             this.log(composerLock ? '[dry-run] Would write composer.json and composer.lock' : '[dry-run] Would write composer.json');
-            return;
+            return { status: 'dry-run', wroteLock: composerLock !== undefined };
         }
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         await writeFile(composerJsonPath, composerJson, 'utf8');
         if (composerLock === undefined) {
             this.log('Wrote composer.json (no composer.lock on this site yet)');
-            return;
+            return { status: 'success', wroteLock: false };
         }
         const lockPath = join(process.cwd(), this.rootDir, 'composer.lock');
         await writeFile(lockPath, composerLock, 'utf8');
         this.log(`Wrote composer.json and composer.lock`);
+        return { status: 'success', wroteLock: true };
     }
 }

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

@@ -1,10 +1,17 @@
 import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    hasLock: boolean;
+    packageCount: number;
+    status: 'dry-run' | 'success';
+};
 export default class ComposerPush extends PushCommand {
     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<void>;
+    run(): Promise<PushResult>;
 }
+export {};

package/dist/commands/composer/push.js

@@ -7,6 +7,7 @@ import { isTimeoutError } from '../../lib/wp-client.js';
 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 enableJsonFlag = true;
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -32,7 +33,7 @@ export default class ComposerPush extends PushCommand {
             this.warn('No composer.lock found. The server will resolve versions freely.');
         }
         if (this.dryRun)
-            return;
+            return { hasLock, packageCount, status: 'dry-run' };
         this.log('Running composer install on the server, this can take a few minutes...');
         try {
             await this.wp.post('loopress/v1/composer/sync', {
@@ -48,5 +49,6 @@ export default class ComposerPush extends PushCommand {
         }
         this.log('composer install completed on the server.');
         await this.recordSuccess();
+        return { hasLock, packageCount, status: 'success' };
     }
 }

package/dist/commands/dev.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Dev extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        skip: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private parseTypeFlag;
+    private pushBatch;
+    private watch;
+}