@loopress/cli 0.20.1 → 0.22.0

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';
@@ -16,7 +17,7 @@ export default class Push extends Command {
     yes = false;
     async run() {
         const { flags } = await this.parse(Push);
-        this.yes = Boolean(flags.yes);
+        this.yes = flags.yes;
         const token = authManager.getAuth()?.token;
         if (!token) {
             this.error('Not logged in. Run `lps login` first.');
@@ -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);
@@ -158,8 +163,8 @@ export default class Push extends Command {
         }
         const match = apiProject?.environments.find((candidate) => candidate.name === env.name && !claimedEnvironmentIds.has(candidate.id));
         if (match) {
-            const link = await this.confirmLink(`Environment "${env.name}" already exists on "${apiProject?.name}". Link to it instead of creating a new one?`);
-            if (link) {
+            const isLink = await this.confirmLink(`Environment "${env.name}" already exists on "${apiProject?.name}". Link to it instead of creating a new one?`);
+            if (isLink) {
                 claimedEnvironmentIds.add(match.id);
                 return { action: 'link', apiEnvironmentId: match.id, env, projectId };
             }
@@ -174,14 +179,30 @@ export default class Push extends Command {
         const slug = toSlug(project.name);
         const match = apiProjects.find((candidate) => candidate.slug === slug && !claimedProjectIds.has(candidate.id));
         if (match) {
-            const link = await this.confirmLink(`A project named "${project.name}" already exists on your account. Link to it instead of creating a new one?`);
-            if (link) {
+            const isLink = await this.confirmLink(`A project named "${project.name}" already exists on your account. Link to it instead of creating a new one?`);
+            if (isLink) {
                 claimedProjectIds.add(match.id);
                 return { action: 'link', apiProjectId: match.id, project };
             }
         }
         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/project/switch.js

@@ -28,7 +28,7 @@ export default class Switch extends Command {
             return { envName: env.name, projectId: project.id, projectName: project.name };
         }
         const choices = groups.flatMap(({ envs, project }) => [
-            new Separator(project.isCurrent ? c('green', `─── ${project.name} ───`) : c('dim', `─── ${project.name} ───`)),
+            new Separator(c(project.isCurrent ? 'green' : 'dim', `─── ${project.name} ───`)),
             ...envs.map((env) => ({
                 name: `${env.name.padEnd(20)} ${env.url}${env.isCurrent ? ' [current]' : ''}`,
                 value: `${project.id}::${env.name}`,
@@ -40,7 +40,7 @@ export default class Switch extends Command {
             default: current && `${current.project.id}::${current.env.name}`,
             message: 'Select project / environment',
         });
-        const [projectId, envName] = chosen.split('::');
+        const [projectId, envName] = chosen.split('::', 2);
         const { project } = groups.find((group) => group.project.id === projectId);
         return { envName, projectId, projectName: project.name };
     }

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

package/dist/commands/seo/list.js

@@ -3,9 +3,9 @@ import { LoopressCommand } from '../../lib/base.js';
 import { DEFAULT_POST_TYPES, SEO_REDIRECTS_ENDPOINT, seoPostMetaEndpoint } from '../../utils/seo-format.js';
 export default class List extends LoopressCommand {
     static description = 'List posts with SEO meta, and redirects if supported by the active SEO plugin, on WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps seo list', '$ lps seo list --post-type post'];
     static flags = {
-        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
         'post-type': Flags.string({ description: 'Limit to specific post types', multiple: true }),
     };
     async run() {
@@ -16,10 +16,6 @@ export default class List extends LoopressCommand {
             byType[postType] = await this.wp.get(seoPostMetaEndpoint(postType));
         }
         const { redirects, unsupportedReason } = await this.fetchRedirects();
-        if (flags.json) {
-            this.log(JSON.stringify({ postMeta: byType, redirects: redirects ?? undefined, redirectsUnsupported: unsupportedReason }, null, 2));
-            return;
-        }
         for (const postType of postTypes) {
             const posts = byType[postType];
             this.log(`${postType} (${posts.length}):`);
@@ -35,16 +31,18 @@ export default class List extends LoopressCommand {
         }
         if (unsupportedReason) {
             this.log(`redirects: ${unsupportedReason}`);
-            return;
+            return { postMeta: byType, redirects: undefined, redirectsUnsupported: unsupportedReason };
         }
         this.log(`redirects (${redirects.length}):`);
-        if (redirects.length === 0) {
-            this.log('  (none)');
-            return;
+        if (redirects.length > 0) {
+            for (const redirect of redirects) {
+                this.log(`  ${redirect.id}. [${redirect.status}] ${redirect.headerCode} -> ${redirect.urlTo}`);
+            }
         }
-        for (const redirect of redirects) {
-            this.log(`  ${redirect.id}. [${redirect.status}] ${redirect.headerCode} -> ${redirect.urlTo}`);
+        else {
+            this.log('  (none)');
         }
+        return { postMeta: byType, redirects: redirects, redirectsUnsupported: undefined };
     }
     // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast); reported
     // as a line in the listing rather than failing the whole command, since post meta above may

package/dist/commands/seo/pull.js

@@ -1,5 +1,4 @@
 import { Args, Flags } from '@oclif/core';
-import { Listr } from 'listr2';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
@@ -36,24 +35,13 @@ export default class Pull extends LoopressCommand {
             extensions: ['.json'],
             key: basenameKey,
         });
-        if (this.dryRun) {
-            this.log(`[dry-run] Would pull ${remote.length} ${postType} post-meta file(s) to ${dir}`);
-            if (orphans.length > 0) {
-                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
-            }
-            return;
-        }
-        if (remote.length > 0)
-            await mkdir(dir, { recursive: true });
-        await new Listr(remote.map((post) => ({
-            async task(_ctx, task) {
-                await writeFile(join(dir, `${post.slug}.json`), JSON.stringify(post, null, 2) + '\n');
-                task.output = `Pulled: ${post.slug}`;
-            },
-            title: `Pull ${post.slug}`,
-        }))).run();
-        await this.removeOrphanedFiles(dir, orphans, `in ${dir} no longer present on WordPress`);
-        this.log(`Pulled ${remote.length} ${postType} post-meta file(s) to ${dir}`);
+        await this.pullDirectory(dir, remote, orphans, {
+            dryRunMessage: `Would pull ${remote.length} ${postType} post-meta file(s) to ${dir}`,
+            orphanReason: `in ${dir} no longer present on WordPress`,
+            pulledMessage: `Pulled ${remote.length} ${postType} post-meta file(s) to ${dir}`,
+            title: (post) => post.slug,
+            write: async (post, writeDir) => writeFile(join(writeDir, `${post.slug}.json`), JSON.stringify(post, null, 2) + '\n'),
+        });
     }
     // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast). Unlike
     // push (which must fail loudly if the user has local redirect files that can't be synced),
@@ -73,24 +61,13 @@ export default class Pull extends LoopressCommand {
             extensions: ['.json'],
             key: numericPrefixKey,
         });
-        if (this.dryRun) {
-            this.log(`[dry-run] Would pull ${remote.length} redirect(s) to ${dir}`);
-            if (orphans.length > 0) {
-                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
-            }
-            return;
-        }
-        if (remote.length > 0)
-            await mkdir(dir, { recursive: true });
-        await new Listr(remote.map((redirect) => ({
-            async task(_ctx, task) {
-                await writeFile(join(dir, `${redirectFileBase(redirect)}.json`), JSON.stringify(redirect, null, 2) + '\n');
-                task.output = `Pulled: redirect #${redirect.id}`;
-            },
-            title: `Pull redirect #${redirect.id}`,
-        }))).run();
-        await this.removeOrphanedFiles(dir, orphans, `in ${dir} no longer present on WordPress`);
-        this.log(`Pulled ${remote.length} redirect(s) to ${dir}`);
+        await this.pullDirectory(dir, remote, orphans, {
+            dryRunMessage: `Would pull ${remote.length} redirect(s) to ${dir}`,
+            orphanReason: `in ${dir} no longer present on WordPress`,
+            pulledMessage: `Pulled ${remote.length} redirect(s) to ${dir}`,
+            title: (redirect) => `redirect #${redirect.id}`,
+            write: async (redirect, writeDir) => writeFile(join(writeDir, `${redirectFileBase(redirect)}.json`), JSON.stringify(redirect, null, 2) + '\n'),
+        });
     }
     async pullSettings(basePath) {
         const file = join(basePath, 'settings.json');