@loopress/cli 0.18.0 → 0.20.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/publish.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Publish extends Command {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/api/publish.js

@@ -0,0 +1,60 @@
+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';
+// 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
+// is a special case of the same publish/deploy rules as snippets and ACF (see
+// obsidian/Product/API and Console Backlog.md, US-18): a `push` (direct to WordPress, this
+// project's own site) and a `publish` (to the cloud, deployable to other projects) are two
+// separate, coexisting paths.
+export default class Publish extends Command {
+    static args = {
+        path: Args.string({ description: 'Path to api directory (overrides project config)' }),
+    };
+    static description = 'Publish custom API routes to your Loopress account so they can be deployed to other projects. Does not touch any WordPress site.';
+    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 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),
+            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`, {
+                routes: files,
+            });
+            await api.post(`projects/${project.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.`);
+    }
+}

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

@@ -6,8 +6,8 @@ export default class Pull extends LoopressCommand {
     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 findOrphanedFiles;
 }

package/dist/commands/api/pull.js

@@ -1,8 +1,9 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
+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)' }),
@@ -11,6 +12,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps api pull', '$ lps api pull --path ./api'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Pull);
@@ -19,11 +21,13 @@ export default class Pull extends LoopressCommand {
         this.log(`Pulling API routes from ${url}`);
         this.log(`API path: ${path}`);
         const files = await this.wp.get('loopress/v1/api-files');
-        // Files following the `<filename>.php` convention no longer present remotely belong to
-        // a route deleted on WordPress. Left on disk, they'd silently come back to life the next
-        // time `api push` runs (see obsidian/Product/Push Deletion Rules.md: push itself stays
-        // additive-only, but pull already cleans up locally, same as `snippet pull`).
-        const orphans = await this.findOrphanedFiles(path, new Set(files.map((file) => file.filename)));
+        // 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) {
@@ -39,26 +43,7 @@ export default class Pull extends LoopressCommand {
             },
             title: `Pull ${file.filename}`,
         }))).run();
-        for (const file of orphans)
-            await rm(join(path, file), { force: true });
-        if (orphans.length > 0) {
-            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} whose route no longer exists on WordPress: ${orphans.join(', ')}`);
-        }
+        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}`);
     }
-    // Only ever matches `.php` files already following the flat `<filename>.php` convention
-    // that `api pull`/`push` themselves produce, so a hand-created non-.php file is never at
-    // risk of being picked up here.
-    async findOrphanedFiles(path, keepFilenames) {
-        let entries;
-        try {
-            entries = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        return entries.filter((entry) => entry.endsWith('.php') && !keepFilenames.has(entry.slice(0, -4)));
-    }
 }

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

@@ -6,10 +6,11 @@ export default class Push 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>;
     };
-    private failedCount;
     run(): Promise<void>;
     private loadFiles;
     private pushFile;
+    private syncApiRoutes;
 }

package/dist/commands/api/push.js

@@ -1,8 +1,18 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+import { basename } 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-]+$/;
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to api directory (overrides project config)' }),
@@ -11,8 +21,8 @@ export default class Push extends PushCommand {
     static examples = ['$ lps api push', '$ lps api push --path ./api'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
-    failedCount = 0;
     async run() {
         const { args } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -31,28 +41,21 @@ export default class Push extends PushCommand {
         if (this.dryRun)
             return;
         await this.recordSuccess();
+        await this.syncApiRoutes(files.map((file) => file.filename));
         this.log('All API routes pushed.');
     }
     async loadFiles(path) {
-        let entries;
-        try {
-            entries = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        const files = [];
-        for (const entry of entries) {
-            if (extname(entry) !== '.php')
-                continue;
-            const content = await readFile(join(path, entry), 'utf8');
-            files.push({ content, filename: entry.slice(0, -4) });
-        }
-        return files;
+        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}`;
@@ -64,13 +67,23 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${file.filename}`;
         }
         catch (error) {
-            const message = `Failed to push ${file.filename}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);
+        }
+    }
+    // Best-effort report of the current file list to the Loopress cloud, purely for console
+    // visibility (see obsidian/Product/API and Console Backlog.md, US-18): the routes are already
+    // live on WordPress by this point, this can never block or fail the push itself, same
+    // reasoning as `recordDeployment` in PushCommand.
+    async syncApiRoutes(filenames) {
+        const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token;
+        const environmentId = this.siteConfig.apiEnvironmentId;
+        if (!token || !environmentId)
+            return;
+        try {
+            await new ApiClient(token).put('api-routes', { environmentId, filenames });
+        }
+        catch {
+            // non-blocking: reporting the route list must never interrupt the push flow
         }
     }
 }

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/pull.d.ts

@@ -6,9 +6,8 @@ export default class Pull extends LoopressCommand {
     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 findOrphanedFiles;
 }
-export declare function slug(title: string): string;