@loopress/cli 0.21.0 → 0.22.0

package/dist/commands/plugin/pull.js

@@ -17,21 +17,14 @@ 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})`);
-            }
+            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 });
@@ -42,4 +35,9 @@ export default class Pull extends LoopressCommand {
             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

@@ -15,7 +15,10 @@ export default class Push extends PushCommand {
     };
     run(): Promise<PushResult>;
     private activatePlugin;
+    private applyPluginChanges;
     private installPlugin;
+    private logPlannedChanges;
+    private logSkippedComposerManaged;
     private performPluginAction;
 }
 export {};

package/dist/commands/plugin/push.js

@@ -2,6 +2,7 @@ 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;
@@ -20,10 +21,7 @@ export default class Push extends PushCommand {
         const composerSlugs = composerJson ? getComposerManagedSlugs(composerJson) : [];
         const filteredManifest = Object.fromEntries(Object.entries(manifest).filter(([slug]) => !composerSlugs.includes(slug)));
         const skippedComposerManaged = composerSlugs.filter((slug) => Object.hasOwn(manifest, slug));
-        if (skippedComposerManaged.length > 0) {
-            this.log(`Skipping ${skippedComposerManaged.length} Composer-managed ${skippedComposerManaged.length === 1 ? 'plugin' : 'plugins'}: ${skippedComposerManaged.join(', ')}`);
-            this.log('Run `lps composer push` to deploy them.');
-        }
+        this.logSkippedComposerManaged(skippedComposerManaged);
         this.log(`Pushing plugins to ${url}`);
         const raw = await this.wp.get('wp/v2/plugins');
         const installed = parseInstalledPlugins(raw);
@@ -32,22 +30,24 @@ export default class Push extends PushCommand {
             this.log('Everything is already in sync.');
             return { activated: [], installed: [], skippedComposerManaged, status: 'in-sync' };
         }
-        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}`);
-        }
+        this.logPlannedChanges(toInstall, toActivate);
         const installedSlugs = toInstall.map((a) => a.slug);
         const activatedSlugs = toActivate.map((a) => a.slug);
         if (this.dryRun)
             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),
@@ -60,18 +60,28 @@ export default class Push extends PushCommand {
                 title: `Activate ${action.slug}`,
             })), { 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();
-        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 installPlugin(slug, 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 {
             await request();

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;
+}