@loopress/cli 0.24.0 → 0.25.0

package/dist/commands/menu/pull.js

@@ -0,0 +1,72 @@
+import { Args } from '@oclif/core';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
+import { MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../../utils/menu-format.js';
+// The reserved local filename for menu locations (see pullLocations()): a menu genuinely slugged
+// "menu-locations" would collide with it, so it's skipped rather than silently overwriting that file.
+const LOCATIONS_FILE_BASENAME = 'menu-locations';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to menus directory (overrides project config)' }),
+    };
+    static description = 'Pull nav menus and the active theme menu locations from WordPress';
+    static examples = ['$ lps menu pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolveMenuPath(args.path);
+        this.log(`Pulling nav menus from ${url}`);
+        this.log(`Menus path: ${path}`);
+        await this.pullMenus(path);
+        await this.pullLocations(path);
+    }
+    async pullLocations(basePath) {
+        const file = join(basePath, `${LOCATIONS_FILE_BASENAME}.json`);
+        const locations = await this.wp.get(MENU_LOCATIONS_ENDPOINT);
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull locations to ${file}`);
+            return;
+        }
+        await mkdir(basePath, { recursive: true });
+        await writeFile(file, JSON.stringify(locations, null, 2) + '\n');
+        this.log(`Pulled locations to ${file}`);
+    }
+    async pullMenus(dir) {
+        const fetched = await this.wp.get(MENU_ENDPOINT);
+        const remote = fetched.filter((menu) => {
+            if (menu.slug === LOCATIONS_FILE_BASENAME) {
+                this.warn(`Skipping menu "${menu.slug}": this filename is reserved for ${LOCATIONS_FILE_BASENAME}.json`);
+                return false;
+            }
+            return true;
+        });
+        const orphans = await findOrphanedFiles(dir, new Set(remote.map((menu) => menu.slug)), {
+            extensions: ['.json'],
+            key: (base) => (base === LOCATIONS_FILE_BASENAME ? null : basenameKey(base)),
+        });
+        await this.pullDirectory(dir, remote, orphans, {
+            dryRunMessage: `Would pull ${remote.length} menu(s) to ${dir}`,
+            orphanReason: `in ${dir} no longer present on WordPress`,
+            pulledMessage: `Pulled ${remote.length} menu(s) to ${dir}`,
+            title: (menu) => menu.slug,
+            // revision/warnings are server bookkeeping, never part of the tracked configuration (see
+            // their doc comments on Menu in menu-format.ts): never persisted locally.
+            async write(menu, writeDir) {
+                const local = { items: menu.items, name: menu.name, slug: menu.slug };
+                await writeFile(join(writeDir, `${menu.slug}.json`), JSON.stringify(local, null, 2) + '\n');
+            },
+        });
+        if (this.dryRun)
+            return;
+        for (const menu of remote) {
+            for (const warning of menu.warnings)
+                this.warn(`${menu.slug}: ${warning}`);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { PushCommand } from '../../lib/push-command.js';
+export default class Push extends PushCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, 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 currentRevision;
+    private pushLocations;
+    private pushMenuFile;
+    private pushMenus;
+}

package/dist/commands/menu/push.js

@@ -0,0 +1,120 @@
+import { Args } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { PushCommand } from '../../lib/push-command.js';
+import { readdirTolerant } from '../../lib/readdir-tolerant.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT, menuEndpoint } from '../../utils/menu-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+// A menu literally slugged "menu-locations" would still collide, but that's far less likely
+// than the plain "locations" this used to be (WordPress's own menu-locations feature).
+const LOCATIONS_FILENAME = 'menu-locations.json';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to menus directory (overrides project config)' }),
+    };
+    static description = 'Push local nav menus and the active theme menu locations to WordPress. Each menu\'s post_type/taxonomy items are resolved by slug on the target environment, never by a raw id; an item whose target does not exist there fails the whole menu rather than guessing.';
+    static examples = ['$ lps menu push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveMenuPath(args.path);
+        this.log(`Pushing nav menus to ${url}`);
+        this.log(`Menus path: ${path}`);
+        const provider = getResourceStateProvider('menu');
+        const beforeState = await this.captureBeforePushState(provider, path);
+        await this.pushMenus(path);
+        await this.pushLocations(path);
+        await this.writeAfterPushSnapshot(provider, path, beforeState);
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'menu')} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All nav menus pushed.');
+    }
+    async currentRevision(slug) {
+        try {
+            const current = await this.wp.get(menuEndpoint(slug));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async pushLocations(basePath) {
+        const file = join(basePath, LOCATIONS_FILENAME);
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${file}`);
+            return;
+        }
+        try {
+            await this.wp.put(MENU_LOCATIONS_ENDPOINT, JSON.parse(raw));
+            this.log(`Pushed: ${file}`);
+        }
+        catch (error) {
+            this.failedCount++;
+            this.warn(`Failed to push ${file}: ${error.message}`);
+        }
+    }
+    async pushMenuFile(filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const parsed = JSON.parse(await readFile(filePath, 'utf8'));
+            if (typeof parsed !== 'object' || parsed === null)
+                throw new Error('not a JSON object');
+            const record = parsed;
+            const slug = getMenuSlug(record);
+            if (slug === null)
+                throw new Error('missing or invalid "slug"');
+            const name = typeof record.name === 'string' ? record.name : '';
+            const items = record.items ?? [];
+            if (!Array.isArray(items))
+                throw new Error('"items" must be an array');
+            // Read the menu's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the menu
+            // in between, instead of this push silently overwriting it (#234). No revision to condition
+            // on for a menu that doesn't exist remotely yet (a first push, an upsert create): falls back
+            // to today's unconditional write, same as before this existed.
+            const expectedRevision = await this.currentRevision(slug);
+            const body = { items, name, slug };
+            if (expectedRevision !== undefined)
+                body.expectedRevision = expectedRevision;
+            const result = await this.wp.post(MENU_ENDPOINT, body);
+            if (task) {
+                task.output = result.warnings.length > 0 ? `Pushed: ${slug} (warning: ${result.warnings.join('; ')})` : `Pushed: ${slug}`;
+            }
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${filePath}: ${error.message}`, error, task);
+        }
+    }
+    async pushMenus(basePath) {
+        const files = (await readdirTolerant(basePath)).filter((file) => extname(file) === '.json' && file !== LOCATIONS_FILENAME);
+        if (files.length === 0)
+            return;
+        this.log(`Found ${pluralize(files.length, 'menu')} to push`);
+        await this.runPushTasks(files, (file) => file, async (file, task) => this.pushMenuFile(join(basePath, file), task));
+    }
+}

package/dist/commands/menu/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/menu/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('menu', {
+    description: 'Restore nav menus and menu locations to a snapshot taken automatically before an earlier `lps menu push`',
+    pathNoun: 'menus directory',
+});

package/dist/commands/option/add.js

@@ -33,7 +33,7 @@ export default class Add extends LoopressCommand {
             }
             throw error;
         }
-        const local = { ...remote, readonly: defaultReadonlyFor(name) };
+        const local = { autoload: remote.autoload, name: remote.name, readonly: defaultReadonlyFor(name), value: remote.value };
         const file = join(dir, optionFileName(name));
         if (this.dryRun) {
             this.log(`[dry-run] Would track "${name}" at ${file}`);

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

@@ -16,6 +16,7 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private currentRevision;
     private pushOption;
 }
 export {};

package/dist/commands/option/push.js

@@ -1,6 +1,8 @@
 import { Args } from '@oclif/core';
 import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
 import { optionEndpoint, parseLocalOption, partitionByReadonly } from '../../utils/option-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
@@ -21,6 +23,8 @@ export default class Push extends PushCommand {
         const { url } = this.siteConfig;
         this.log(`Pushing tracked options to ${url}`);
         this.log(`Options path: ${dir}`);
+        const provider = getResourceStateProvider('option');
+        const beforeState = await this.captureBeforePushState(provider, dir);
         const tracked = await loadFiles(dir, {
             extension: '.json',
             onSkip: (message) => {
@@ -38,6 +42,7 @@ export default class Push extends PushCommand {
             await this.pushOption(option, task);
             pushed.push(option.name);
         });
+        await this.writeAfterPushSnapshot(provider, dir, beforeState);
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'option')} failed to push.`);
         }
@@ -48,6 +53,17 @@ export default class Push extends PushCommand {
         this.log('All options pushed.');
         return { pushed, skipped: skippedNames, status: 'success' };
     }
+    async currentRevision(name) {
+        try {
+            const current = await this.wp.get(optionEndpoint(name));
+            return current.revision;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        }
+    }
     async pushOption(option, task) {
         if (this.dryRun) {
             if (task)
@@ -55,7 +71,16 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.put(optionEndpoint(option.name), { autoload: option.autoload, value: option.value });
+            // Read the option's current revision right before writing it, and send it back as
+            // `expectedRevision`: WordPress refuses the write (412) if something else changed the
+            // option in between, instead of this push silently overwriting it (#234). No revision to
+            // condition on for an option that doesn't exist remotely yet (a first push, an upsert
+            // create): falls back to today's unconditional write, same as before this existed.
+            const expectedRevision = await this.currentRevision(option.name);
+            const body = { autoload: option.autoload, value: option.value };
+            if (expectedRevision !== undefined)
+                body.expectedRevision = expectedRevision;
+            await this.wp.put(optionEndpoint(option.name), body);
             if (task)
                 task.output = `Pushed: ${option.name}`;
         }

package/dist/commands/option/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/option/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('option', {
+    description: 'Restore tracked options to a snapshot taken automatically before an earlier `lps option push`',
+    pathNoun: 'options directory',
+});

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

@@ -22,6 +22,7 @@ export default class Push extends PushCommand {
     private deactivate;
     private deactivateEndangered;
     private fetchInstanceLock;
+    private filesForNewlyInstalled;
     private guardForce;
     private result;
     private sync;

package/dist/commands/plugin/push.js

@@ -70,6 +70,7 @@ export default class Push extends PushCommand {
             await this.activate(deactivated.filter((p) => !diff.toRemove.includes(p.slug)));
             throw error;
         }
+        toReactivate.push(...(await this.filesForNewlyInstalled(diff.toInstall)));
         if (toPrune.length > 0) {
             await this.deactivate(installed.filter((p) => toPrune.includes(p.slug)));
         }
@@ -126,6 +127,19 @@ export default class Push extends PushCommand {
             throw error;
         }
     }
+    // toInstall entries carry no `file`: the plugin didn't exist on the site at diff time, so its
+    // WordPress core plugin id (folder/main-file.php) is only knowable after sync() has actually
+    // installed it. Refetch to get it, then activate like everything else.
+    async filesForNewlyInstalled(toInstall) {
+        if (toInstall.length === 0)
+            return [];
+        const installedAfterSync = parseInstalledPlugins(await this.wp.get('wp/v2/plugins'));
+        const fileBySlug = new Map(installedAfterSync.map((p) => [p.slug, p.file]));
+        return toInstall.flatMap(({ slug }) => {
+            const file = fileBySlug.get(slug);
+            return file ? [{ file, slug }] : [];
+        });
+    }
     guardForce(diff, force) {
         if (force)
             return;

package/dist/commands/promote.d.ts

@@ -1,18 +1,25 @@
 import { Command } from '@oclif/core';
+type PromoteResult = {
+    from: string;
+    status: 'dry-run' | 'promoted';
+    to: string;
+};
 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 enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<PromoteResult>;
     private confirmPromotion;
     private delegateArgv;
     private requireEnvironment;
     private resolveProject;
 }
+export {};

package/dist/commands/promote.js

@@ -10,6 +10,7 @@ export default class Promote extends Command {
         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 enableJsonFlag = true;
     static examples = ['$ lps promote staging production', '$ lps promote production staging --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -38,6 +39,7 @@ export default class Promote extends Command {
         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}.`);
+        return { from: from.name, status: dryRun ? 'dry-run' : '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

package/dist/commands/pull.d.ts

@@ -1,12 +1,22 @@
 import { LoopressCommand } from '../lib/base.js';
+type PullTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pulled';
+};
+type PullResult = {
+    results: PullTargetResult[];
+};
 export default class Pull extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     private failedCount;
-    run(): Promise<void>;
+    run(): Promise<PullResult>;
     private buildArgv;
 }
+export {};

package/dist/commands/pull.js

@@ -11,11 +11,13 @@ const PULL_TARGETS = [
     { commandId: 'hook:pull', label: 'hooks', supportsYes: true },
     { commandId: 'form:pull', label: 'forms', supportsYes: true },
     { commandId: 'seo:pull', label: 'SEO', supportsYes: true },
+    { commandId: 'menu:pull', label: 'menus', supportsYes: true },
     { commandId: 'option:pull', label: 'options', 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, hooks, forms, SEO, options, and snippets, from WordPress';
+    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -23,21 +25,26 @@ export default class Pull extends LoopressCommand {
     };
     failedCount = 0;
     async run() {
+        const results = [];
         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`);
+                results.push({ label: target.label, status: 'pulled' });
             }
             catch (error) {
                 this.failedCount++;
-                this.log(`✗ ${target.label} failed: ${error.message}`);
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
             }
         }
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'resource')} failed to pull.`);
         }
         this.log('\nAll resources pulled.');
+        return { results };
     }
     // `--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.

package/dist/commands/push.d.ts

@@ -1,13 +1,23 @@
 import { LoopressCommand } from '../lib/base.js';
+type PushTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pushed';
+};
+type PushResult = {
+    results: PushTargetResult[];
+};
 export default class Push extends LoopressCommand {
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     private failedCount;
-    run(): Promise<void>;
+    run(): Promise<PushResult>;
     private buildArgv;
     private guardProductionPush;
 }
+export {};

package/dist/commands/push.js

@@ -11,11 +11,13 @@ const PUSH_TARGETS = [
     { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
     { commandId: 'seo:push', label: 'SEO' },
+    { commandId: 'menu:push', label: 'menus' },
     { commandId: 'option:push', label: 'options' },
     { commandId: 'snippet:push', label: 'snippets' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, to WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -25,21 +27,26 @@ export default class Push extends LoopressCommand {
     async run() {
         await this.guardProductionPush();
         const argv = this.buildArgv();
+        const results = [];
         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`);
+                results.push({ label: target.label, status: 'pushed' });
             }
             catch (error) {
                 this.failedCount++;
-                this.log(`✗ ${target.label} failed: ${error.message}`);
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
             }
         }
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'resource')} failed to push.`);
         }
         this.log('\nAll resources pushed.');
+        return { results };
     }
     // 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.

package/dist/commands/seo/pull.js

@@ -40,7 +40,9 @@ export default class Pull extends LoopressCommand {
             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'),
+            // `revision` (#234) is never persisted locally, same as RemoteOption.revision: it's only
+            // ever read fresh, right before a push, never trusted from a stale local file.
+            write: async ({ meta, slug, title }, writeDir) => writeFile(join(writeDir, `${slug}.json`), JSON.stringify({ meta, slug, title }, null, 2) + '\n'),
         });
     }
     // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast). Unlike
@@ -71,7 +73,9 @@ export default class Pull extends LoopressCommand {
     }
     async pullSettings(basePath) {
         const file = join(basePath, 'settings.json');
-        const settings = await this.wp.get(SEO_SETTINGS_ENDPOINT);
+        // `revision` (#234) is never persisted locally, same as RemoteOption.revision: settings.json
+        // holds only the settings themselves, exactly as it did before the wrapped response shape.
+        const { settings } = await this.wp.get(SEO_SETTINGS_ENDPOINT);
         if (this.dryRun) {
             this.log(`[dry-run] Would pull settings to ${file}`);
             return;

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

@@ -6,10 +6,13 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'allow-external-redirects': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    private allowExternalRedirects;
     run(): Promise<void>;
+    private currentPostMetaRevision;
     private jsonFilesIn;
     private pushPostMeta;
     private pushPostMetaFile;