@loopress/cli 0.20.0 → 0.21.0

package/dist/commands/api/list.js

@@ -1,26 +1,19 @@
-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 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('');
         for (const file of files) {
             this.log(`  ${file.filename}`);
         }
+        return files;
     }
 }

package/dist/commands/api/publish.js

@@ -40,7 +40,7 @@ export default class Publish extends Command {
         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);

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,7 +1,7 @@
 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';
 export default class Pull extends LoopressCommand {
@@ -9,6 +9,7 @@ export default class Pull extends LoopressCommand {
         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,31 @@ export default class Pull extends LoopressCommand {
         const orphans = await findOrphanedFiles(path, new Set(files.map((file) => file.filename)), {
             extensions: ['.php'],
             key: basenameKey,
+            recursive: true,
         });
+        const pulled = files.map((file) => file.filename);
         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;
+            return { orphans, pulled, status: 'dry-run' };
         }
         await mkdir(path, { recursive: true });
         await new Listr(files.map((file) => ({
             async task(_ctx, task) {
-                await writeFile(join(path, `${file.filename}.php`), file.content);
+                const filePath = join(path, `${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);
                 task.output = `Pulled: ${file.filename}`;
             },
             title: `Pull ${file.filename}`,
-        }))).run();
+        })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).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}`);
+        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-]+$/;
+// 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,
@@ -31,29 +37,46 @@ export default class Push extends PushCommand {
         this.log(`API path: ${path}`);
         const files = await this.loadFiles(path);
         this.log(`Found ${files.length} route file${files.length === 1 ? '' : 's'} to push`);
+        const pushed = [];
         await new Listr(files.map((file) => ({
-            task: async (_ctx, task) => this.pushFile(file, task),
+            task: async (_ctx, task) => {
+                await this.pushFile(file, task);
+                pushed.push(file.filename);
+            },
             title: `Push ${file.filename}`,
-        })), { concurrent: false, exitOnError: false }).run();
+        })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
         if (this.failedCount > 0) {
             this.error(`${this.failedCount} route file${this.failedCount === 1 ? '' : 's'} 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 +85,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

@@ -1,8 +1,27 @@
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+// Narrower than isNotFoundError(): a bare 404 also covers the route being absent (plugin not
+// installed, or an edition/version predating Composer support), which must still surface the
+// normal "is the plugin installed?" guidance rather than being read as "no lock yet".
+function isMissingComposerLock(error) {
+    if (!isNotFoundError(error))
+        return false;
+    const body = error.cause?.response?.body;
+    if (!body)
+        return false;
+    try {
+        const parsed = JSON.parse(body);
+        return parsed.error === 'composer.lock not found';
+    }
+    catch {
+        return false;
+    }
+}
 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,
@@ -11,15 +30,33 @@ export default class ComposerPull extends LoopressCommand {
         const { url } = this.siteConfig;
         this.log(`Pulling composer.json and composer.lock from ${url}`);
         const { composerJson } = await this.wp.get('loopress/v1/composer/json');
-        const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+        // A site that never had Composer dependencies pushed has no composer.lock yet: that's a
+        // legitimate applicative 404 from the Loopress controller (ComposerController::get_lock(),
+        // body `{"error": "composer.lock not found"}`), not a sign anything is broken. Any other
+        // 404 (route absent because the plugin isn't installed or predates Composer support) must
+        // still surface the normal "is the plugin installed?" guidance instead of being swallowed.
+        let composerLock;
+        try {
+            ;
+            ({ composerLock } = await this.wp.get('loopress/v1/composer/lock'));
+        }
+        catch (error) {
+            if (!isMissingComposerLock(error))
+                throw error;
+        }
         if (this.dryRun) {
-            this.log('[dry-run] Would write composer.json and composer.lock');
-            return;
+            this.log(composerLock ? '[dry-run] Would write composer.json and composer.lock' : '[dry-run] Would write composer.json');
+            return { status: 'dry-run', wroteLock: composerLock !== undefined };
         }
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
-        const lockPath = join(process.cwd(), this.rootDir, 'composer.lock');
         await writeFile(composerJsonPath, composerJson, 'utf8');
+        if (composerLock === undefined) {
+            this.log('Wrote composer.json (no composer.lock on this site yet)');
+            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;
+}

package/dist/commands/dev.js

@@ -0,0 +1,97 @@
+import { Command, Flags } from '@oclif/core';
+import { watch as watchFiles } from 'chokidar';
+import { basename } from 'node:path';
+import { configManager } from '../config/project-config.manager.js';
+import { buildWatchTargets, createDebouncedBatcher, resolveResourceTypes, RESOURCE_TYPES, resourceTypeForPath } from '../lib/dev-watch.js';
+import { readLocalConfig } from '../utils/loopress-config.js';
+const DEBOUNCE_MS = 400;
+// Noise no one wants pushed: VCS internals, deps, and editor/OS droppings.
+const IGNORED = /(^|[/\\])(\.git|node_modules|\.DS_Store)(?:[/\\]|$)|\.swp$/;
+export default class Dev extends Command {
+    static description = 'Watch project files and push changes to the local WordPress instance as they happen. Always targets the "local" environment, run `lps snippet push` etc. directly for any other environment.';
+    static examples = ['$ lps dev', '$ lps dev --only=snippets,pages', '$ lps dev --skip=plugins'];
+    static flags = {
+        only: Flags.string({ description: `Only watch these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),
+        skip: Flags.string({ description: `Skip these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),
+    };
+    async run() {
+        const { flags } = await this.parse(Dev);
+        const only = flags.only ? this.parseTypeFlag(flags.only, 'only') : undefined;
+        const skip = flags.skip ? this.parseTypeFlag(flags.skip, 'skip') : [];
+        const types = resolveResourceTypes(only, skip);
+        const localConfig = await readLocalConfig();
+        const projectId = localConfig.projectId ?? configManager.getCurrentProject()?.id;
+        if (!projectId)
+            this.error('No project configured. Run `lps project config` first.');
+        if (!configManager.getEnvironment(projectId, 'local')) {
+            this.error('No "local" environment configured for this project. Run `lps project config` and add a "local" environment.');
+        }
+        const targets = buildWatchTargets(types, localConfig, process.cwd());
+        if (targets.length === 0) {
+            this.error('Nothing to watch: none of the selected resource directories exist yet.');
+        }
+        for (const target of targets)
+            this.log(`Watching ${target.type}: ${target.path}`);
+        await this.watch(targets);
+    }
+    parseTypeFlag(raw, flagName) {
+        return raw
+            .split(',')
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .map((value) => {
+            if (!RESOURCE_TYPES.includes(value)) {
+                this.error(`Unknown resource type "${value}" in --${flagName}. Valid types: ${RESOURCE_TYPES.join(', ')}`);
+            }
+            return value;
+        });
+    }
+    // Sequential on purpose (see notes technique: parallelizing push is out of scope). A failed
+    // push is logged and swallowed here, never thrown, so one bad batch can't take the watcher down.
+    async pushBatch(changesByType, targets) {
+        for (const [type, paths] of changesByType) {
+            const target = targets.find((t) => t.type === type);
+            if (!target)
+                continue;
+            this.log(`\n→ ${type} changed (${paths.map((path) => basename(path)).join(', ')}), pushing to local...`);
+            try {
+                await this.config.runCommand(target.commandId, ['--env', 'local']);
+                this.log(`✓ ${type} synced`);
+            }
+            catch (error) {
+                this.log(`✗ ${type} failed: ${error.message}`);
+            }
+        }
+    }
+    async watch(targets) {
+        const batcher = createDebouncedBatcher(async (paths) => {
+            const changesByType = new Map();
+            for (const path of paths) {
+                const type = resourceTypeForPath(path, targets);
+                if (!type)
+                    continue;
+                changesByType.set(type, [...(changesByType.get(type) ?? []), path]);
+            }
+            await this.pushBatch(changesByType, targets);
+        }, DEBOUNCE_MS);
+        const watcher = watchFiles(targets.map((target) => target.path), {
+            awaitWriteFinish: { pollInterval: 100, stabilityThreshold: 300 },
+            ignoreInitial: true,
+            ignored: (path) => IGNORED.test(path),
+        });
+        watcher
+            .on('add', batcher.queue)
+            .on('change', batcher.queue)
+            .on('unlink', (filePath) => { this.log(`⚠ ${filePath} deleted locally, not synced automatically`); });
+        this.log('\nWatching for changes. Press Ctrl+C to stop.\n');
+        await new Promise((resolve) => {
+            process.once('SIGINT', () => { resolve(); });
+        });
+        batcher.cancel();
+        await watcher.close();
+        // A push failure mid-session sets process.exitCode; stopping the watcher on purpose is a
+        // clean exit regardless of that history (see AC: no meaningful exit code needed for `dev`).
+        process.exitCode = 0;
+        this.log('\nStopped watching.');
+    }
+}

package/dist/commands/doctor.js

@@ -15,12 +15,12 @@ export default class Doctor extends LoopressCommand {
         this.log(`URL:          ${url}`);
         this.log('');
         let failed = 0;
-        const reachable = await this.check('WordPress REST API reachable', async () => {
+        const isReachable = await this.check('WordPress REST API reachable', async () => {
             const diagnostic = await diagnoseWpSite(url);
             if (!diagnostic.ok)
                 throw new Error(diagnostic.reason);
         });
-        if (!reachable) {
+        if (!isReachable) {
             failed++;
             this.log('- Remaining checks skipped while the site is unreachable.');
             this.error('1 check failed.', { exit: 1 });
@@ -34,12 +34,12 @@ export default class Doctor extends LoopressCommand {
         // 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')))) {
+        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)', () => this.wp.get('wp/v2/users/me')))) {
+        if (!(await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me')))) {
             failed++;
         }
         await this.reportPluginVersion();

package/dist/commands/init.js

@@ -29,11 +29,11 @@ export default class Init extends Command {
         }
         const configPath = join(process.cwd(), 'loopress.json');
         if (existsSync(configPath)) {
-            const overwrite = await confirm({
+            const isOverwrite = await confirm({
                 default: false,
                 message: 'loopress.json already exists. Overwrite?',
             });
-            if (!overwrite) {
+            if (!isOverwrite) {
                 this.log('Aborted.');
                 return;
             }
@@ -65,11 +65,11 @@ export default class Init extends Command {
                 config[feature.key] = feature.dir;
         }
         await writeLocalConfig(config);
-        let providerAdded = false;
+        let isProviderAdded = false;
         if (providerChoice !== '__none__') {
             try {
                 await this.config.runCommand('plugin:add', [providerChoice]);
-                providerAdded = true;
+                isProviderAdded = true;
             }
             catch (error) {
                 this.warn(error.message);
@@ -83,7 +83,7 @@ export default class Init extends Command {
                 this.log(`  ${feature.label}:${' '.repeat(Math.max(1, 9 - feature.label.length))}${join(rootDir, feature.dir)}`);
             }
         }
-        if (providerAdded) {
+        if (isProviderAdded) {
             this.log(`  Plugin:   ${providerChoice}`);
         }
         this.log('\n→ Next: run `lps snippet pull` to fetch what is already on the site, or `lps doctor` to verify the connection.');
@@ -102,8 +102,8 @@ export default class Init extends Command {
         let projects = configManager.listProjects();
         if (projects.length === 0) {
             this.log('No projects configured yet.');
-            const runConfig = await confirm({ default: true, message: 'Run `lps project config` now to add one?' });
-            if (!runConfig) {
+            const isRunConfig = await confirm({ default: true, message: 'Run `lps project config` now to add one?' });
+            if (!isRunConfig) {
                 return this.promptManualProjectId();
             }
             await this.config.runCommand('project:config');

package/dist/commands/login.js

@@ -10,19 +10,19 @@ export default class Login extends Command {
         authManager.setAuth({ email, savedAt: new Date().toISOString(), token });
         this.log(`\nLogged in${email ? ` as ${email}` : ''}. You're all set!`);
     }
-    waitForCallback() {
+    async waitForCallback() {
         return waitForLocalCallback({
             buildUrl: (callbackBaseUrl) => `${CONSOLE_URL}/cli-auth?callbackUrl=${encodeURIComponent(`${callbackBaseUrl}/callback`)}`,
             handleRequest(url, { resolveWithPage, respondBadRequest }) {
                 const token = url.searchParams.get('token');
-                const email = url.searchParams.get('email') ?? undefined;
                 if (!token) {
                     respondBadRequest('Missing token');
                     return;
                 }
+                const email = url.searchParams.get('email') ?? undefined;
                 resolveWithPage(SUCCESS_PAGE, { email, token });
             },
-            log: (message) => this.log(message),
+            log: (message) => { this.log(message); },
             openingMessage: 'Opening Loopress console in your browser...',
             timeoutMessage: 'Login timed out after 5 minutes. Please try again.',
         });

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

@@ -1,9 +1,7 @@
 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>;
-    };
-    run(): Promise<void>;
+    run(): Promise<Array<Record<string, unknown>>>;
 }