@loopress/cli 0.20.1 → 0.22.0

package/dist/commands/page/push.js

@@ -1,15 +1,17 @@
 import { Args } from '@oclif/core';
-import { Listr } from 'listr2';
-import { readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { readFile, rename, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
-import { isNotFoundError } from '../../lib/wp-client.js';
+import { putOrCreate } from '../../lib/put-or-create.js';
+import { readdirTolerant } from '../../lib/readdir-tolerant.js';
 import { getPageId, getPageTitle, PAGE_ENDPOINT, pageFileBase } from '../../utils/page-format.js';
+import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to pages directory (overrides project config)' }),
     };
     static description = 'Push pages to WordPress. Local files created or updated remotely are renamed on disk to the `<id>-<slug>` convention.';
+    static enableJsonFlag = true;
     static examples = ['$ lps page push'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -22,18 +24,20 @@ export default class Push extends PushCommand {
         this.log(`Pushing pages to ${url}`);
         this.log(`Pages path: ${path}`);
         const pages = await this.loadFiles(path);
-        this.log(`Found ${pages.length} page${pages.length === 1 ? '' : 's'} to push`);
-        await new Listr(pages.map((page) => ({
-            task: async (_ctx, task) => this.pushPage(page, task),
-            title: `Push ${getPageTitle(page.meta)}`,
-        })), { concurrent: false, exitOnError: false }).run();
+        this.log(`Found ${pluralize(pages.length, 'page')} to push`);
+        const pushed = [];
+        await this.runPushTasks(pages, (page) => getPageTitle(page.meta), async (page, task) => {
+            const id = await this.pushPage(page, task);
+            pushed.push({ id, title: getPageTitle(page.meta) });
+        });
         if (this.failedCount > 0) {
-            this.error(`${this.failedCount} page${this.failedCount === 1 ? '' : 's'} failed to push.`);
+            this.error(`${pluralize(this.failedCount, 'page')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { pushed, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All pages pushed.');
+        return { pushed, status: 'success' };
     }
     // Renames the local file pair to the `<id>-<slug>` convention used by `page pull` whenever it
     // doesn't already match, same principle as ensureCanonicalFilename in commands/snippet/push.ts:
@@ -55,15 +59,7 @@ export default class Push extends PushCommand {
     // corrupted or hand-broken sidecar must only skip that page, not abort loading the rest of
     // the directory, same principle as commands/form/push.ts.
     async loadFiles(dir) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
+        const files = await readdirTolerant(dir);
         const pages = [];
         for (const file of files) {
             if (extname(file) !== '.html')
@@ -97,8 +93,6 @@ export default class Push extends PushCommand {
         }
         return pages;
     }
-    // PUT-then-404-fallback-POST, same dance as commands/form/push.ts: pages are id-based.
-    //
     // ponytail: `parent` round-trips as the source site's numeric page id untouched, so pushing
     // to a site where that id belongs to a different page (or nothing) silently mis-parents or
     // orphans the page. No id-remapping across sites here; fine for same-hierarchy environments,
@@ -108,40 +102,28 @@ export default class Push extends PushCommand {
         if (this.dryRun) {
             if (task)
                 task.output = `[dry-run] Would push: ${title}`;
-            return;
+            return getPageId(page.meta);
         }
         try {
             const id = getPageId(page.meta);
             const payload = { ...page.meta, content: page.content };
-            if (id === null) {
-                const created = await this.wp.post(PAGE_ENDPOINT, payload);
-                const newId = getPageId(created);
-                if (newId !== null)
-                    await this.ensureCanonicalFilename(page, newId, title);
-            }
-            else {
-                try {
-                    await this.wp.put(`${PAGE_ENDPOINT}/${id}`, payload);
-                    await this.ensureCanonicalFilename(page, id, title);
-                }
-                catch (error) {
-                    // The id recorded locally doesn't exist on this site (e.g. a fresh install): create
-                    // it instead of failing, and adopt whatever id the site assigns. WordPress core
-                    // rejects any POST that still carries a (now stale) `id` field with a 400 "Cannot
-                    // create existing post", regardless of whether that id actually exists, so it must
-                    // be stripped before falling back to create.
-                    if (!isNotFoundError(error))
-                        throw error;
-                    const createPayload = { ...payload };
-                    delete createPayload.id;
-                    const created = await this.wp.post(PAGE_ENDPOINT, createPayload);
-                    const newId = getPageId(created);
-                    if (newId !== null)
-                        await this.ensureCanonicalFilename(page, newId, title);
-                }
-            }
+            // WordPress core rejects any POST that still carries a (now stale) `id` field with a
+            // 400 "Cannot create existing post", regardless of whether that id actually exists.
+            const postPayload = { ...payload };
+            delete postPayload.id;
+            const { body, created } = await putOrCreate(this.wp, {
+                id,
+                payload,
+                postEndpoint: PAGE_ENDPOINT,
+                postPayload,
+                putEndpoint: (pageId) => `${PAGE_ENDPOINT}/${pageId}`,
+            });
+            const resultId = created ? getPageId(body) : id;
+            if (resultId !== null)
+                await this.ensureCanonicalFilename(page, resultId, title);
             if (task)
                 task.output = `Pushed: ${title}`;
+            return resultId;
         }
         catch (error) {
             this.reportTaskFailure(`Failed to push ${title}: ${error.message}`, error, task);

package/dist/commands/plugin/add.js

@@ -18,15 +18,15 @@ export default class Add extends LoopressCommand {
             this.log(`${slug} is already in loopress.json, nothing to do.`);
             return;
         }
-        const updated = existing[slug] !== undefined;
+        const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
-            this.log(`[dry-run] Would ${updated ? 'update' : 'add'} ${slug} in loopress.json`);
+            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} in loopress.json`);
             return;
         }
         await writeLocalConfig({
             ...this.localConfig,
             plugins: { ...existing, [slug]: 'latest' },
         });
-        this.log(`${updated ? 'Updated' : 'Added'} ${slug}`);
+        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug}`);
     }
 }

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

@@ -1,9 +1,16 @@
 import { LoopressCommand } from '../../lib/base.js';
+import { type MergeResult } from '../../utils/plugins.js';
+type PullResult = MergeResult & {
+    status: 'dry-run' | 'success';
+};
 export default class Pull 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>;
+    private logSkippedComposerManaged;
 }
+export {};

package/dist/commands/plugin/pull.js

@@ -4,6 +4,7 @@ import { writeLocalConfig } from '../../utils/loopress-config.js';
 import { mergePluginManifest, parseInstalledPlugins } from '../../utils/plugins.js';
 export default class Pull extends LoopressCommand {
     static description = 'Pull installed plugins from WordPress into loopress.json';
+    static enableJsonFlag = true;
     static examples = ['$ lps plugin pull', '$ lps plugin pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -16,22 +17,15 @@ export default class Pull extends LoopressCommand {
         const composerJson = await readComposerJson();
         const composerSlugs = composerJson ? getComposerManagedSlugs(composerJson) : [];
         const incoming = Object.fromEntries(installed.filter((p) => !composerSlugs.includes(p.slug)).map((p) => [p.slug, 'latest']));
-        if (composerSlugs.length > 0) {
-            const found = installed.filter((p) => composerSlugs.includes(p.slug)).map((p) => p.slug);
-            if (found.length > 0) {
-                this.log(`Skipping ${found.length} Composer-managed ${found.length === 1 ? 'plugin' : 'plugins'}: ${found.join(', ')}`);
-            }
-        }
+        this.logSkippedComposerManaged(installed.filter((p) => composerSlugs.includes(p.slug)).map((p) => p.slug));
         const { added, merged, updated } = mergePluginManifest(this.localConfig.plugins ?? {}, incoming);
         if (this.dryRun) {
             this.log(`[dry-run] Would write ${Object.keys(merged).length} plugins to loopress.json`);
             if (added.length > 0)
                 this.log(`  + ${added.join(', ')}`);
-            if (updated.length > 0) {
-                for (const u of updated)
-                    this.log(`  ~ ${u.slug} (${u.from} → ${u.to})`);
-            }
-            return;
+            for (const u of updated)
+                this.log(`  ~ ${u.slug} (${u.from} → ${u.to})`);
+            return { added, merged, status: 'dry-run', updated };
         }
         await writeLocalConfig({ ...this.localConfig, plugins: merged });
         this.log(`Wrote ${Object.keys(merged).length} plugins to loopress.json`);
@@ -39,5 +33,11 @@ export default class Pull extends LoopressCommand {
             this.log(`  + Added: ${added.join(', ')}`);
         for (const u of updated)
             this.log(`  ~ Updated: ${u.slug} ${u.from} → ${u.to}`);
+        return { added, merged, status: 'success', updated };
+    }
+    logSkippedComposerManaged(found) {
+        if (found.length > 0) {
+            this.log(`Skipping ${found.length} Composer-managed ${found.length === 1 ? 'plugin' : 'plugins'}: ${found.join(', ')}`);
+        }
     }
 }

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

@@ -1,13 +1,24 @@
 import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    activated: string[];
+    installed: string[];
+    skippedComposerManaged: string[];
+    status: 'dry-run' | 'in-sync' | 'success';
+};
 export default class Push 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>;
     private activatePlugin;
+    private applyPluginChanges;
     private installPlugin;
+    private logPlannedChanges;
+    private logSkippedComposerManaged;
     private performPluginAction;
 }
+export {};

package/dist/commands/plugin/push.js

@@ -2,8 +2,10 @@ import { Listr } from 'listr2';
 import { PushCommand } from '../../lib/push-command.js';
 import { getComposerManagedSlugs, readComposerJson } from '../../utils/composer.js';
 import { diffPlugins, parseInstalledPlugins } from '../../utils/plugins.js';
+import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
     static description = 'Push plugins to WordPress to match loopress.json';
+    static enableJsonFlag = true;
     static examples = ['$ lps plugin push', '$ lps plugin push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -18,55 +20,67 @@ export default class Push extends PushCommand {
         const composerJson = await readComposerJson();
         const composerSlugs = composerJson ? getComposerManagedSlugs(composerJson) : [];
         const filteredManifest = Object.fromEntries(Object.entries(manifest).filter(([slug]) => !composerSlugs.includes(slug)));
-        const skipped = composerSlugs.filter((slug) => slug in manifest);
-        if (skipped.length > 0) {
-            this.log(`Skipping ${skipped.length} Composer-managed ${skipped.length === 1 ? 'plugin' : 'plugins'}: ${skipped.join(', ')}`);
-            this.log('Run `lps composer push` to deploy them.');
-        }
+        const skippedComposerManaged = composerSlugs.filter((slug) => Object.hasOwn(manifest, slug));
+        this.logSkippedComposerManaged(skippedComposerManaged);
         this.log(`Pushing plugins to ${url}`);
         const raw = await this.wp.get('wp/v2/plugins');
         const installed = parseInstalledPlugins(raw);
         const { toActivate, toInstall } = diffPlugins(filteredManifest, installed);
         if (toInstall.length === 0 && toActivate.length === 0) {
             this.log('Everything is already in sync.');
-            return;
-        }
-        if (toInstall.length > 0) {
-            this.log(`\nTo install (${toInstall.length}):`);
-            for (const a of toInstall)
-                this.log(`  + ${a.slug}`);
-        }
-        if (toActivate.length > 0) {
-            this.log(`\nTo activate (${toActivate.length}):`);
-            for (const a of toActivate)
-                this.log(`  ↑ ${a.slug}`);
+            return { activated: [], installed: [], skippedComposerManaged, status: 'in-sync' };
         }
+        this.logPlannedChanges(toInstall, toActivate);
+        const installedSlugs = toInstall.map((a) => a.slug);
+        const activatedSlugs = toActivate.map((a) => a.slug);
         if (this.dryRun)
-            return;
+            return { activated: activatedSlugs, installed: installedSlugs, skippedComposerManaged, status: 'dry-run' };
         // Installing with `status: active` activates in the same call, so installs never need a
         // separate activation step the way the old custom endpoint's two-step flow did.
+        await this.applyPluginChanges(toInstall, toActivate);
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'plugin')} failed to install or activate.`);
+        }
+        await this.recordSuccess();
+        return { activated: activatedSlugs, installed: installedSlugs, skippedComposerManaged, status: 'success' };
+    }
+    async activatePlugin(file, slug, task) {
+        await this.performPluginAction('activate', slug, async () => this.wp.put(`wp/v2/plugins/${file}`, { status: 'active' }), task);
+    }
+    async applyPluginChanges(toInstall, toActivate) {
         if (toInstall.length > 0) {
             await new Listr(toInstall.map((action) => ({
                 task: async (_ctx, task) => this.installPlugin(action.slug, task),
                 title: `Install ${action.slug}`,
-            })), { concurrent: false, exitOnError: false }).run();
+            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
         }
         if (toActivate.length > 0) {
             await new Listr(toActivate.map((action) => ({
                 task: async (_ctx, task) => this.activatePlugin(action.file, action.slug, task),
                 title: `Activate ${action.slug}`,
-            })), { concurrent: false, exitOnError: false }).run();
+            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
         }
-        if (this.failedCount > 0) {
-            this.error(`${this.failedCount} plugin${this.failedCount === 1 ? '' : 's'} failed to install or activate.`);
-        }
-        await this.recordSuccess();
-    }
-    async activatePlugin(file, slug, task) {
-        await this.performPluginAction('activate', slug, () => this.wp.put(`wp/v2/plugins/${file}`, { status: 'active' }), task);
     }
     async installPlugin(slug, task) {
-        await this.performPluginAction('install', slug, () => this.wp.post('wp/v2/plugins', { slug, status: 'active' }), task);
+        await this.performPluginAction('install', slug, async () => this.wp.post('wp/v2/plugins', { slug, status: 'active' }), task);
+    }
+    logPlannedChanges(toInstall, toActivate) {
+        if (toInstall.length > 0) {
+            this.log(`\nTo install (${toInstall.length}):`);
+            for (const a of toInstall)
+                this.log(`  + ${a.slug}`);
+        }
+        if (toActivate.length > 0) {
+            this.log(`\nTo activate (${toActivate.length}):`);
+            for (const a of toActivate)
+                this.log(`  ↑ ${a.slug}`);
+        }
+    }
+    logSkippedComposerManaged(skippedComposerManaged) {
+        if (skippedComposerManaged.length === 0)
+            return;
+        this.log(`Skipping ${skippedComposerManaged.length} Composer-managed ${skippedComposerManaged.length === 1 ? 'plugin' : 'plugins'}: ${skippedComposerManaged.join(', ')}`);
+        this.log('Run `lps composer push` to deploy them.');
     }
     async performPluginAction(verb, slug, request, task) {
         try {

package/dist/commands/project/config.js

@@ -36,11 +36,11 @@ export default class Config extends Command {
             : envChoice;
         const existingEnv = configManager.getEnvironment(projectId, envName);
         if (existingEnv) {
-            const overwrite = await confirm({
+            const isOverwrite = await confirm({
                 default: false,
                 message: `"${projectName}/${envName}" already exists. Overwrite?`,
             });
-            if (!overwrite) {
+            if (!isOverwrite) {
                 this.log('Aborted.');
                 return;
             }
@@ -60,7 +60,10 @@ export default class Config extends Command {
                 }
             },
         });
-        const url = rawUrl.replace(/\/+$/, '');
+        let url = rawUrl;
+        while (url.endsWith('/')) {
+            url = url.slice(0, -1);
+        }
         const { appPassword, user } = await this.resolveCredentials(url);
         const token = `${user}:${appPassword}`;
         const env = {
@@ -92,17 +95,17 @@ export default class Config extends Command {
         // A detection failure (network hiccup, plugins REST disabled) is treated as "assume it's
         // there" rather than surprising the user with an account-creating prompt they didn't ask
         // for; `lps project config` can simply be re-run if it genuinely isn't installed.
-        const alreadyActive = await isLoopressFullActive(wp).catch(() => true);
-        if (alreadyActive)
+        const isAlreadyActive = await isLoopressFullActive(wp).catch(() => true);
+        if (isAlreadyActive)
             return;
-        const proceed = await confirm({
+        const isProceed = await confirm({
             default: true,
             message: 'Loopress Full was not detected on this site. Install it now? (creates a temporary admin account, removed automatically afterward)',
         });
-        if (!proceed)
+        if (!isProceed)
             return;
         try {
-            await bootstrapLoopressFull(wp, url, (message) => this.log(message));
+            await bootstrapLoopressFull(wp, url, (message) => { this.log(message); });
         }
         catch (error) {
             this.warn(error.message);
@@ -137,7 +140,7 @@ export default class Config extends Command {
             return this.promptManualCredentials();
         }
         try {
-            const { password, userLogin } = await authorizeWithBrowser(url, (message) => this.log(message));
+            const { password, userLogin } = await authorizeWithBrowser(url, (message) => { this.log(message); });
             return { appPassword: password, user: userLogin };
         }
         catch (error) {

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

@@ -1,6 +1,21 @@
 import { Command } from '@oclif/core';
+type EnvironmentInfo = {
+    isCurrent: boolean;
+    name: string;
+    url: string;
+};
+type ProjectInfo = {
+    environments: EnvironmentInfo[];
+    id: string;
+    isCurrent: boolean;
+    name: string;
+};
 export default class List extends Command {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
-    run(): Promise<void>;
+    run(): Promise<ProjectInfo[]>;
+    private logEnvironment;
+    private logProject;
 }
+export {};

package/dist/commands/project/list.js

@@ -3,28 +3,34 @@ import { configManager } from '../../config/project-config.manager.js';
 const c = ux.colorize;
 export default class List extends Command {
     static description = 'List configured WordPress projects';
+    static enableJsonFlag = true;
     static examples = ['$ lps project list'];
     async run() {
         await this.parse(List);
         const projects = configManager.listProjects();
         if (projects.length === 0) {
             this.log('No projects configured. Run `lps project config` first.');
-            return;
-        }
-        for (const project of projects) {
-            const envs = configManager.listEnvironments(project.id);
-            const marker = project.isCurrent ? c('green', '●') : c('dim', '○');
-            const name = project.isCurrent ? c('green', project.name) : project.name;
-            const currentTag = project.isCurrent ? ` ${c('green', '[current]')}` : '';
-            this.log(`${marker} ${name}${currentTag}`);
-            for (const env of envs) {
-                const envMarker = env.isCurrent ? c('cyan', '·') : c('dim', '·');
-                const envName = env.isCurrent ? c('cyan', env.name.padEnd(15)) : c('dim', env.name.padEnd(15));
-                const envUrl = c('dim', env.url);
-                const activeTag = env.isCurrent ? ` ${c('cyan', '←')}` : '';
-                this.log(`  ${envMarker} ${envName} ${envUrl}${activeTag}`);
-            }
-            this.log('');
+            return [];
         }
+        return projects.map((project) => this.logProject(project));
+    }
+    // Only name/url/isCurrent are surfaced, deliberately: EnvironmentConfig also carries the
+    // WordPress application password token, which must never end up in --json output.
+    logEnvironment(env) {
+        const envMarker = c(env.isCurrent ? 'cyan' : 'dim', '·');
+        const envName = c(env.isCurrent ? 'cyan' : 'dim', env.name.padEnd(15));
+        const envUrl = c('dim', env.url);
+        const activeTag = env.isCurrent ? ` ${c('cyan', '←')}` : '';
+        this.log(`  ${envMarker} ${envName} ${envUrl}${activeTag}`);
+        return { isCurrent: env.isCurrent, name: env.name, url: env.url };
+    }
+    logProject(project) {
+        const marker = project.isCurrent ? c('green', '●') : c('dim', '○');
+        const name = project.isCurrent ? c('green', project.name) : project.name;
+        const currentTag = project.isCurrent ? ` ${c('green', '[current]')}` : '';
+        this.log(`${marker} ${name}${currentTag}`);
+        const environments = configManager.listEnvironments(project.id).map((env) => this.logEnvironment(env));
+        this.log('');
+        return { environments, id: project.id, isCurrent: project.isCurrent, name: project.name };
     }
 }

package/dist/commands/project/pull.js

@@ -3,6 +3,7 @@ import { Listr } from 'listr2';
 import { authManager } from '../../config/auth.manager.js';
 import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
+import { pluralize } from '../../utils/pluralize.js';
 export default class Pull extends Command {
     static description = 'Pull projects and environments from your Loopress account that are not configured locally yet';
     static examples = ['$ lps project pull'];
@@ -31,7 +32,7 @@ export default class Pull extends Command {
                 title: `Pull project "${apiProject.name}" from the API`,
             })), { concurrent: false, exitOnError: false }).run();
         }
-        this.log(`\n✓ Pulled ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} from your Loopress account`);
+        this.log(`\n✓ Pulled ${pluralize(projectCount, 'project')}, ${pluralize(environmentCount, 'environment')} from your Loopress account`);
     }
     async fetchApiProjects(api) {
         try {
@@ -64,6 +65,6 @@ export default class Pull extends Command {
         });
         const envCount = apiProject.environments.length;
         if (task)
-            task.output = `Pulled with ${envCount} environment${envCount === 1 ? '' : 's'}`;
+            task.output = `Pulled with ${pluralize(envCount, 'environment')}`;
     }
 }

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

@@ -8,10 +8,15 @@ export default class Push extends Command {
     private yes;
     run(): Promise<void>;
     private applyEnvironment;
+    private applyEnvironmentPlans;
     private applyProject;
+    private applyProjectPlans;
+    private collectEnvsNeedingWork;
     private confirmLink;
     private fetchApiProjects;
+    private planAll;
     private planEnvironment;
     private planProject;
+    private pushAllCredentials;
     private pushCredentials;
 }