@loopress/cli 0.21.0 → 0.23.0

package/dist/commands/plugin/status.js

@@ -0,0 +1,65 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { diffPlugins, lockedWpackagistSlugs, parseInstalledPlugins } from '../../utils/plugins.js';
+export default class Status extends LoopressCommand {
+    static description = 'Compare the plugins on WordPress against loopress.json and report drift';
+    static enableJsonFlag = true;
+    static examples = ['$ lps plugin status'];
+    static flags = {};
+    async run() {
+        const { url } = this.siteConfig;
+        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
+            this.warn('This project has a composer.json, which is authoritative for plugins. Run `lps composer` commands instead.');
+            return { drift: false, inactive: [], missing: [], status: 'composer-managed', untrackedActive: [], wrongVersion: [] };
+        }
+        const manifest = this.localConfig.plugins ?? {};
+        const raw = await this.wp.get('wp/v2/plugins');
+        const installed = parseInstalledPlugins(raw);
+        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'plugin');
+        const diff = diffPlugins(manifest, installed, managed);
+        const missing = diff.toInstall.map((a) => a.slug);
+        const wrongVersion = diff.toPin.map((p) => ({ live: p.from, pinned: p.to, slug: p.slug }));
+        const inactive = diff.toActivate.map((a) => a.slug);
+        const { untrackedActive } = diff;
+        // `collisions` are also drift (Loopress doesn't own them yet); surface them under missing's
+        // banner so `plugin push --force` is the obvious next step.
+        const collisions = diff.collisions.map((c) => c.slug);
+        const drift = missing.length > 0 ||
+            wrongVersion.length > 0 ||
+            inactive.length > 0 ||
+            diff.toRemove.length > 0 ||
+            collisions.length > 0;
+        if (!drift && untrackedActive.length === 0) {
+            this.log(`In sync with loopress.json (${url})`);
+            return { drift: false, inactive: [], missing: [], status: 'in-sync', untrackedActive: [], wrongVersion: [] };
+        }
+        if (missing.length > 0)
+            this.log(`Not installed: ${missing.join(', ')}`);
+        if (collisions.length > 0)
+            this.log(`Installed outside Loopress (run \`plugin push --force\`): ${collisions.join(', ')}`);
+        for (const w of wrongVersion)
+            this.log(`Version drift: ${w.slug} is ${w.live}, loopress.json pins ${w.pinned}`);
+        if (inactive.length > 0)
+            this.log(`Pinned but inactive: ${inactive.join(', ')}`);
+        if (diff.toRemove.length > 0)
+            this.log(`Managed by Loopress but dropped from loopress.json: ${diff.toRemove.join(', ')}`);
+        if (untrackedActive.length > 0)
+            this.log(`Active but untracked: ${untrackedActive.join(', ')}`);
+        if (drift)
+            this.exit(1);
+        return { drift, inactive, missing, status: drift ? 'drift' : 'in-sync', untrackedActive, wrongVersion };
+    }
+    async fetchInstanceLock() {
+        try {
+            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+            return composerLock;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+    }
+}

package/dist/commands/project/config.js

@@ -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 = {

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 = 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}`);
-            }
-            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;
 }

package/dist/commands/project/push.js

@@ -6,6 +6,7 @@ import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 import { LoopressCommand } from '../../lib/base.js';
 import { isInteractive } from '../../lib/interactive.js';
+import { pluralize } from '../../utils/pluralize.js';
 import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends Command {
     static description = 'Push locally configured projects, environments and credentials to your Loopress account';
@@ -28,67 +29,15 @@ export default class Push extends Command {
         }
         const api = new ApiClient(token);
         const apiProjects = await this.fetchApiProjects(api);
-        const claimedProjectIds = new Set();
-        const envPlansByProject = new Map();
-        const projectPlans = [];
-        for (const project of projects) {
-            const plan = await this.planProject(project, apiProjects, claimedProjectIds);
-            projectPlans.push(plan);
-            const apiProject = plan.apiProjectId ? apiProjects.find((candidate) => candidate.id === plan.apiProjectId) : undefined;
-            const claimedEnvironmentIds = new Set();
-            const envPlans = [];
-            for (const env of configManager.listEnvironments(project.id)) {
-                envPlans.push(plan.action === 'create'
-                    ? { action: 'create', env, projectId: project.id }
-                    : await this.planEnvironment(env, project.id, apiProject, claimedEnvironmentIds));
-            }
-            envPlansByProject.set(project.id, envPlans);
-        }
+        const { envPlansByProject, projectPlans } = await this.planAll(projects, apiProjects);
         let projectCount = projectPlans.filter((plan) => plan.action === 'synced').length;
         let environmentCount = [...envPlansByProject.values()].flat().filter((plan) => plan.action === 'synced').length;
         const projectsNeedingWork = projectPlans.filter((plan) => plan.action !== 'synced');
-        if (projectsNeedingWork.length > 0) {
-            await new Listr(projectsNeedingWork.map((plan) => ({
-                task: async (_ctx, task) => {
-                    await this.applyProject(api, plan, task);
-                    projectCount++;
-                },
-                title: plan.action === 'create'
-                    ? `Create project "${plan.project.name}" on the API`
-                    : `Link project "${plan.project.name}" to the API`,
-            })), { concurrent: false, exitOnError: false }).run();
-        }
-        const envsNeedingWork = projectPlans
-            .filter((plan) => Boolean(plan.apiProjectId))
-            .flatMap((plan) => (envPlansByProject.get(plan.project.id) ?? [])
-            .filter((envPlan) => envPlan.action !== 'synced')
-            .map((envPlan) => ({ apiProjectId: plan.apiProjectId, envPlan, projectName: plan.project.name })));
-        if (envsNeedingWork.length > 0) {
-            await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
-                task: async (_ctx, task) => {
-                    await this.applyEnvironment(api, apiProjectId, envPlan, task);
-                    environmentCount++;
-                },
-                title: envPlan.action === 'create'
-                    ? `Create environment "${envPlan.env.name}" on "${projectName}"`
-                    : `Link environment "${envPlan.env.name}" on "${projectName}"`,
-            })), { concurrent: false, exitOnError: false }).run();
-        }
-        for (const plan of projectPlans) {
-            if (!plan.apiProjectId)
-                continue;
-            for (const envPlan of envPlansByProject.get(plan.project.id) ?? []) {
-                if (!envPlan.apiEnvironmentId || !envPlan.env.token)
-                    continue;
-                try {
-                    await this.pushCredentials(api, plan.apiProjectId, envPlan.apiEnvironmentId, envPlan.env);
-                }
-                catch (error) {
-                    this.warn(`Failed to push "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
-                }
-            }
-        }
-        this.log(`\n✓ Pushed ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} to your Loopress account`);
+        projectCount += await this.applyProjectPlans(api, projectsNeedingWork);
+        const envsNeedingWork = this.collectEnvsNeedingWork(projectPlans, envPlansByProject);
+        environmentCount += await this.applyEnvironmentPlans(api, envsNeedingWork);
+        await this.pushAllCredentials(api, projectPlans, envPlansByProject);
+        this.log(`\n✓ Pushed ${pluralize(projectCount, 'project')}, ${pluralize(environmentCount, 'environment')} to your Loopress account`);
     }
     async applyEnvironment(api, apiProjectId, envPlan, task) {
         try {
@@ -113,6 +62,21 @@ export default class Push extends Command {
             throw error;
         }
     }
+    async applyEnvironmentPlans(api, envsNeedingWork) {
+        if (envsNeedingWork.length === 0)
+            return 0;
+        let count = 0;
+        await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
+            task: async (_ctx, task) => {
+                await this.applyEnvironment(api, apiProjectId, envPlan, task);
+                count++;
+            },
+            title: envPlan.action === 'create'
+                ? `Create environment "${envPlan.env.name}" on "${projectName}"`
+                : `Link environment "${envPlan.env.name}" on "${projectName}"`,
+        })), { concurrent: false, exitOnError: false }).run();
+        return count;
+    }
     async applyProject(api, plan, task) {
         try {
             if (plan.action === 'create') {
@@ -133,6 +97,28 @@ export default class Push extends Command {
             throw error;
         }
     }
+    async applyProjectPlans(api, projectsNeedingWork) {
+        if (projectsNeedingWork.length === 0)
+            return 0;
+        let count = 0;
+        await new Listr(projectsNeedingWork.map((plan) => ({
+            task: async (_ctx, task) => {
+                await this.applyProject(api, plan, task);
+                count++;
+            },
+            title: plan.action === 'create'
+                ? `Create project "${plan.project.name}" on the API`
+                : `Link project "${plan.project.name}" to the API`,
+        })), { concurrent: false, exitOnError: false }).run();
+        return count;
+    }
+    collectEnvsNeedingWork(projectPlans, envPlansByProject) {
+        return projectPlans
+            .filter((plan) => Boolean(plan.apiProjectId))
+            .flatMap((plan) => (envPlansByProject.get(plan.project.id) ?? [])
+            .filter((envPlan) => envPlan.action !== 'synced')
+            .map((envPlan) => ({ apiProjectId: plan.apiProjectId, envPlan, projectName: plan.project.name })));
+    }
     // Linking to the existing match is the safe default: outside a TTY (or with --yes) it is
     // taken without prompting, and logged, so CI runs never mint duplicate projects.
     async confirmLink(message) {
@@ -151,6 +137,25 @@ export default class Push extends Command {
             return [];
         }
     }
+    async planAll(projects, apiProjects) {
+        const claimedProjectIds = new Set();
+        const envPlansByProject = new Map();
+        const projectPlans = [];
+        for (const project of projects) {
+            const plan = await this.planProject(project, apiProjects, claimedProjectIds);
+            projectPlans.push(plan);
+            const apiProject = plan.apiProjectId ? apiProjects.find((candidate) => candidate.id === plan.apiProjectId) : undefined;
+            const claimedEnvironmentIds = new Set();
+            const envPlans = [];
+            for (const env of configManager.listEnvironments(project.id)) {
+                envPlans.push(plan.action === 'create'
+                    ? { action: 'create', env, projectId: project.id }
+                    : await this.planEnvironment(env, project.id, apiProject, claimedEnvironmentIds));
+            }
+            envPlansByProject.set(project.id, envPlans);
+        }
+        return { envPlansByProject, projectPlans };
+    }
     async planEnvironment(env, projectId, apiProject, claimedEnvironmentIds) {
         if (env.apiEnvironmentId) {
             claimedEnvironmentIds.add(env.apiEnvironmentId);
@@ -182,6 +187,22 @@ export default class Push extends Command {
         }
         return { action: 'create', project };
     }
+    async pushAllCredentials(api, projectPlans, envPlansByProject) {
+        for (const plan of projectPlans) {
+            if (!plan.apiProjectId)
+                continue;
+            for (const envPlan of envPlansByProject.get(plan.project.id) ?? []) {
+                if (!envPlan.apiEnvironmentId || !envPlan.env.token)
+                    continue;
+                try {
+                    await this.pushCredentials(api, plan.apiProjectId, envPlan.apiEnvironmentId, envPlan.env);
+                }
+                catch (error) {
+                    this.warn(`Failed to push "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
+                }
+            }
+        }
+    }
     async pushCredentials(api, apiProjectId, apiEnvironmentId, env) {
         if (!env.token)
             return;

package/dist/commands/promote.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Promote extends Command {
+    static args: {
+        from: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        to: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private confirmPromotion;
+    private delegateArgv;
+    private requireEnvironment;
+    private resolveProject;
+}

package/dist/commands/promote.js

@@ -0,0 +1,90 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Command } from '@oclif/core';
+import { configManager } from '../config/project-config.manager.js';
+import { LoopressCommand } from '../lib/base.js';
+import { isInteractive } from '../lib/interactive.js';
+import { readLocalConfig } from '../utils/loopress-config.js';
+export default class Promote extends Command {
+    static args = {
+        from: Args.string({ description: 'Environment to copy the configuration from', required: true }),
+        to: Args.string({ description: 'Environment to copy the configuration to', required: true }),
+    };
+    static description = 'Copy every tracked resource from one environment to another by pulling from <from> then pushing to <to>. Local tracked files are overwritten with <from> in the process.';
+    static examples = ['$ lps promote staging production', '$ lps promote production staging --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args, flags } = await this.parse(Promote);
+        const { yes } = flags;
+        const dryRun = flags['dry-run'];
+        const { environments, projectName } = await this.resolveProject();
+        const from = this.requireEnvironment(environments, projectName, args.from);
+        const to = this.requireEnvironment(environments, projectName, args.to);
+        if (from.name === to.name) {
+            this.error('<from> and <to> must be different environments.');
+        }
+        if (!dryRun)
+            await this.confirmPromotion(from.name, to.name, to.url, yes);
+        this.log(`\n=== Pulling from ${from.name} (${from.url}) ===`);
+        try {
+            await this.config.runCommand('pull', this.delegateArgv(from.name, dryRun));
+        }
+        catch (error) {
+            // A partial pull must never be pushed onward: stop before touching <to>.
+            this.error(`Pull from ${from.name} failed, ${to.name} left untouched: ${error.message}`);
+        }
+        this.log(`\n=== Pushing to ${to.name} (${to.url}) ===`);
+        await this.config.runCommand('push', this.delegateArgv(to.name, dryRun));
+        this.log(dryRun ? `\n[dry-run] ${from.name} would be promoted to ${to.name}.` : `\n${from.name} promoted to ${to.name}.`);
+    }
+    // Deliberately not `guardProductionPush`: promote overwrites local tracked files for every
+    // target, not just production, so it needs its own confirmation regardless of the name. That
+    // prompt also calls out production when relevant, making a second production-only guard
+    // redundant.
+    async confirmPromotion(from, to, toUrl, yes) {
+        if (yes)
+            return;
+        const isProduction = to.toLowerCase() === 'production';
+        const warning = isProduction ? ` "${to}" is a production environment.` : '';
+        if (!isInteractive()) {
+            this.error(`This overwrites local tracked files with ${from} and pushes them to ${to} (${toUrl}).${warning} Pass --yes to confirm.`);
+        }
+        const isProceed = await confirm({
+            default: !isProduction,
+            message: `Promote ${from} to ${to} (${toUrl})? This overwrites local tracked files with ${from}.${warning}`,
+        });
+        if (!isProceed)
+            this.error('Aborted.');
+    }
+    // `--yes` is always forwarded: confirmPromotion above already gathered intent once, so the
+    // delegated `pull` and `push` must not prompt again (push would otherwise re-run its own
+    // production guard, and pull its orphan-deletion prompt).
+    delegateArgv(env, dryRun) {
+        const argv = ['--env', env, '--yes'];
+        if (dryRun)
+            argv.push('--dry-run');
+        return argv;
+    }
+    requireEnvironment(environments, projectName, name) {
+        const env = environments[name];
+        if (!env) {
+            this.error(`Environment "${name}" not found in project "${projectName}". Available: ${Object.keys(environments).join(', ')}`);
+        }
+        return env;
+    }
+    // Same project resolution as base.ts / status.ts: the pinned project from loopress.json, or
+    // the globally active one.
+    async resolveProject() {
+        const { projectId } = await readLocalConfig();
+        const project = projectId ? configManager.getProject(projectId) : configManager.getCurrentProject();
+        if (!project) {
+            this.error('No project configured. Run `lps project config` first.');
+        }
+        if (Object.keys(project.environments).length === 0) {
+            this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
+        }
+        return { environments: project.environments, projectName: project.name };
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,12 @@
+import { LoopressCommand } from '../lib/base.js';
+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>;
+    };
+    private failedCount;
+    run(): Promise<void>;
+    private buildArgv;
+}

package/dist/commands/pull.js

@@ -0,0 +1,51 @@
+import { LoopressCommand } from '../lib/base.js';
+import { pluralize } from '../utils/pluralize.js';
+// composer before plugins: `plugin:pull` reads the local composer.json to skip
+// Composer-managed plugins, so it needs the freshly pulled one. The rest write to independent
+// directories and their order does not matter, it mirrors `lps push` for familiarity.
+const PULL_TARGETS = [
+    { commandId: 'composer:pull', label: 'composer' },
+    { commandId: 'plugin:pull', label: 'plugins' },
+    { commandId: 'acf:pull', label: 'ACF', supportsYes: true },
+    { commandId: 'api:pull', label: 'API routes', supportsYes: true },
+    { commandId: 'form:pull', label: 'forms', supportsYes: true },
+    { commandId: 'page:pull', label: 'pages', supportsYes: true },
+    { commandId: 'seo:pull', label: 'SEO', supportsYes: true },
+    { commandId: 'snippet:pull', label: 'snippets', supportsYes: true },
+];
+export default class Pull extends LoopressCommand {
+    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, forms, pages, SEO, and snippets, from WordPress';
+    static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    failedCount = 0;
+    async run() {
+        for (const target of PULL_TARGETS) {
+            this.log(`\n→ Pulling ${target.label}...`);
+            try {
+                await this.config.runCommand(target.commandId, this.buildArgv(target));
+                this.log(`✓ ${target.label} pulled`);
+            }
+            catch (error) {
+                this.failedCount++;
+                this.log(`✗ ${target.label} failed: ${error.message}`);
+            }
+        }
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'resource')} failed to pull.`);
+        }
+        this.log('\nAll resources pulled.');
+    }
+    // `--yes` is forwarded only when the user passed it and the target accepts it: unlike
+    // `lps push`, a bare `lps pull` should still prompt before removing local files.
+    buildArgv(target) {
+        const argv = ['--env', this.siteConfig.name];
+        if (this.dryRun)
+            argv.push('--dry-run');
+        if (this.yes && target.supportsYes)
+            argv.push('--yes');
+        return argv;
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,13 @@
+import { LoopressCommand } from '../lib/base.js';
+export default class Push 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>;
+    };
+    private failedCount;
+    run(): Promise<void>;
+    private buildArgv;
+    private guardProductionPush;
+}

package/dist/commands/push.js

@@ -0,0 +1,57 @@
+import { LoopressCommand } from '../lib/base.js';
+import { guardProductionPush } from '../lib/guard-production-push.js';
+import { pluralize } from '../utils/pluralize.js';
+// Dependency-ish order: code first (plugins, composer), then the ACF definitions content
+// relies on, then content itself.
+const PUSH_TARGETS = [
+    { commandId: 'plugin:push', label: 'plugins' },
+    { commandId: 'composer:push', label: 'composer' },
+    { commandId: 'acf:push', label: 'ACF' },
+    { commandId: 'api:push', label: 'API routes' },
+    { commandId: 'form:push', label: 'forms' },
+    { commandId: 'page:push', label: 'pages' },
+    { commandId: 'seo:push', label: 'SEO' },
+    { commandId: 'snippet:push', label: 'snippets' },
+];
+export default class Push extends LoopressCommand {
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, forms, pages, SEO, and snippets, to WordPress';
+    static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    failedCount = 0;
+    async run() {
+        await this.guardProductionPush();
+        const argv = this.buildArgv();
+        for (const target of PUSH_TARGETS) {
+            this.log(`\n→ Pushing ${target.label}...`);
+            try {
+                await this.config.runCommand(target.commandId, argv);
+                this.log(`✓ ${target.label} pushed`);
+            }
+            catch (error) {
+                this.failedCount++;
+                this.log(`✗ ${target.label} failed: ${error.message}`);
+            }
+        }
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'resource')} failed to push.`);
+        }
+        this.log('\nAll resources pushed.');
+    }
+    // Every delegated push always gets --yes: either this command's own guard already confirmed
+    // production once above, or the target isn't production and there's nothing to confirm.
+    // Without this, each of the 8 delegated commands would re-run its own production guard.
+    buildArgv() {
+        const argv = ['--env', this.siteConfig.name, '--yes'];
+        if (this.dryRun)
+            argv.push('--dry-run');
+        return argv;
+    }
+    // Guards once here (shared with PushCommand, lib/push-command.ts) rather than once per
+    // delegated command.
+    async guardProductionPush() {
+        await guardProductionPush({ dryRun: this.dryRun, error: (message) => this.error(message), siteConfig: this.siteConfig, yes: this.yes });
+    }
+}

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

@@ -1,11 +1,18 @@
 import { LoopressCommand } from '../../lib/base.js';
+import { type SeoPostMeta, type SeoRedirect } from '../../utils/seo-format.js';
+type ListResult = {
+    postMeta: Record<string, SeoPostMeta[]>;
+    redirects: SeoRedirect[] | undefined;
+    redirectsUnsupported: string | undefined;
+};
 export default class List extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'post-type': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    run(): Promise<void>;
+    run(): Promise<ListResult>;
     private fetchRedirects;
 }
+export {};