@loopress/cli 0.27.0 → 0.29.0

package/dist/commands/promote.js

@@ -1,16 +1,21 @@
 import { confirm } from '@inquirer/prompts';
 import { Args, Command } from '@oclif/core';
+// eslint-disable-next-line n/no-unsupported-features/node-builtins -- stable since 22.3, works unflagged on 22.0+
+import { cp, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
 import { isInteractive } from '../lib/interactive.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
+import { resolveResourceDir, RESOURCE_DIR_DEFAULTS } from '../utils/resource-dirs.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 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. With --dry-run, <from> is pulled into a throwaway copy of the project instead, and the push is only previewed.';
     static enableJsonFlag = true;
     static examples = ['$ lps promote staging production', '$ lps promote production staging --dry-run'];
     static flags = {
@@ -29,19 +34,55 @@ export default class Promote extends Command {
         }
         if (!dryRun)
             await this.confirmPromotion(from.name, to.name, to.url, yes);
-        this.log(`\n=== Pulling from ${from.name} (${from.url}) ===`);
+        // A dry-run pull writes nothing, so a dry-run push right after would preview the current
+        // local files instead of <from>. Instead, really pull into a throwaway copy of the project
+        // and dry-run the push from there: the preview is what a real promotion would push, and the
+        // user's own files stay untouched.
+        const originalCwd = process.cwd();
+        const scratch = dryRun ? await this.enterScratchCopy(originalCwd) : undefined;
+        // The delegated pull is real, so without this its auto-rotation could revoke a stale app
+        // password during what the user asked to be a preview (see LoopressCommand.maybeAutoRotate).
+        const previousNoRotate = process.env.LOOPRESS_NO_AUTO_ROTATE;
+        if (scratch)
+            process.env.LOOPRESS_NO_AUTO_ROTATE = '1';
         try {
-            await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('pull', this.delegateArgv(from.name, dryRun)));
+            this.log(`\n=== Pulling from ${from.name} (${from.url}) ===`);
+            try {
+                await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('pull', this.delegateArgv(from.name, false)));
+            }
+            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 stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', this.delegateArgv(to.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}`);
+        finally {
+            if (scratch) {
+                if (previousNoRotate === undefined)
+                    delete process.env.LOOPRESS_NO_AUTO_ROTATE;
+                else
+                    process.env.LOOPRESS_NO_AUTO_ROTATE = previousNoRotate;
+                process.chdir(originalCwd);
+                await rm(scratch, { force: true, recursive: true });
+            }
         }
-        this.log(`\n=== Pushing to ${to.name} (${to.url}) ===`);
-        await stdoutToStderr(this.jsonEnabled(), async () => 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 };
     }
+    // The scratch pull writes wherever loopress.json points. An absolute or `../` rootDir or
+    // resource dir would land outside the copy, in the user's real files, during a dry run.
+    async assertDirsInsideProject(projectDir) {
+        const localConfig = await readLocalConfig();
+        const dirs = [localConfig.rootDir ?? '.', ...Object.keys(RESOURCE_DIR_DEFAULTS).map((kind) => resolveResourceDir(kind, localConfig))];
+        const outside = dirs.find((dir) => {
+            const rel = relative(projectDir, resolve(projectDir, dir));
+            return rel.startsWith('..') || isAbsolute(rel);
+        });
+        if (outside !== undefined) {
+            this.error(`--dry-run can't preview safely: "${outside}" in loopress.json is outside the project. Run \`lps diff --env <from> --against <to>\` instead.`);
+        }
+    }
     // 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
@@ -70,6 +111,26 @@ export default class Promote extends Command {
             argv.push('--dry-run');
         return argv;
     }
+    // Copies the whole project (not just what `pull` rewrites): push also reads files pull never
+    // touches, and a real promotion pushes those as they are locally. node_modules and .git are
+    // never read by push. Returns the scratch root, cwd is left inside the copy.
+    async enterScratchCopy(projectDir) {
+        await this.assertDirsInsideProject(projectDir);
+        const scratch = await mkdtemp(join(tmpdir(), 'lps-promote-'));
+        try {
+            const copy = join(scratch, basename(projectDir));
+            await cp(projectDir, copy, {
+                filter: (source) => !['.git', 'node_modules'].includes(basename(source)),
+                recursive: true,
+            });
+            process.chdir(copy);
+        }
+        catch (error) {
+            await rm(scratch, { force: true, recursive: true });
+            throw error;
+        }
+        return scratch;
+    }
     requireEnvironment(environments, projectName, name) {
         const env = environments[name];
         if (!env) {

package/dist/commands/pull.js

@@ -1,8 +1,8 @@
 import { LoopressCommand } from '../lib/base.js';
 import { stdoutToStderr } from '../lib/json-delegation.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
+// composer before plugins: when a composer.json exists, `plugin:pull` merges the live plugins
+// into it, so it must run on the freshly pulled one or `composer:pull` would overwrite its work. 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' },

package/dist/commands/push.d.ts

@@ -18,6 +18,7 @@ export default class Push extends LoopressCommand {
     private failedCount;
     run(): Promise<PushResult>;
     private buildArgv;
+    private composerDeclaresPlugins;
     private guardProductionPush;
 }
 export {};

package/dist/commands/push.js

@@ -1,6 +1,11 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { LoopressCommand } from '../lib/base.js';
 import { guardProductionPush } from '../lib/guard-production-push.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
+import { isLocalEnvironment } from '../lib/wp-client.js';
+import { wpackagistRequire } from '../utils/composer.js';
 import { pluralize } from '../utils/pluralize.js';
 // Dependency-ish order: code first (plugins, composer), then the ACF definitions content
 // relies on, then content itself.
@@ -11,6 +16,8 @@ const PUSH_TARGETS = [
     { commandId: 'api:push', label: 'API routes' },
     { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
+    // Before pages: WordPress refuses a page whose `template` it doesn't know yet.
+    { commandId: 'theme:template:push', label: 'templates and parts' },
     { commandId: 'page:push', label: 'pages' },
     { commandId: 'seo:push', label: 'SEO' },
     { commandId: 'menu:push', label: 'menus' },
@@ -18,7 +25,7 @@ const PUSH_TARGETS = [
     { 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, pages, SEO, menus, options, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, templates, pages, SEO, menus, options, and snippets, to WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
@@ -30,11 +37,17 @@ export default class Push extends LoopressCommand {
         await this.guardProductionPush();
         const argv = this.buildArgv();
         const results = [];
+        const composerPushedByPlugins = await this.composerDeclaresPlugins();
         for (const target of PUSH_TARGETS) {
+            if (composerPushedByPlugins && target.commandId === 'composer:push') {
+                this.log('\n→ composer: already pushed whole by plugins');
+                results.push({ label: target.label, status: 'pushed' });
+                continue;
+            }
             this.log(`\n→ Pushing ${target.label}...`);
             try {
                 await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand(target.commandId, argv));
-                this.log(`✓ ${target.label} pushed`);
+                this.log(this.dryRun ? `✓ ${target.label} would push` : `✓ ${target.label} pushed`);
                 results.push({ label: target.label, status: 'pushed' });
             }
             catch (error) {
@@ -47,10 +60,12 @@ export default class Push extends LoopressCommand {
         if (this.failedCount > 0) {
             // Each failure's own reason, not just the count: under --json the per-resource lines above
             // never reach stdout, and this message is all an MCP caller or a script gets to see.
-            const failures = results.filter((result) => result.status === 'failed').map((result) => `${result.label}: ${result.error}`);
+            const failures = results
+                .filter((result) => result.status === 'failed')
+                .map((result) => `${result.label}: ${result.error}`);
             this.error(`${pluralize(this.failedCount, 'resource')} failed to push. ${failures.join('; ')}`);
         }
-        this.log('\nAll resources pushed.');
+        this.log(this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.');
         return { results };
     }
     // Every delegated push always gets --yes: either this command's own guard already confirmed
@@ -62,9 +77,29 @@ export default class Push extends LoopressCommand {
             argv.push('--dry-run');
         return argv;
     }
+    // A composer.json that declares plugins is pushed whole by `plugin:push` (with its activation
+    // safety), so `composer:push` would only run Composer on the server a second time.
+    async composerDeclaresPlugins() {
+        const path = join(process.cwd(), this.rootDir, 'composer.json');
+        if (!existsSync(path))
+            return false;
+        try {
+            const composerJson = JSON.parse(await readFile(path, 'utf8'));
+            return Object.keys(wpackagistRequire(composerJson, 'plugin', isLocalEnvironment(this.siteConfig.name))).length > 0;
+        }
+        catch {
+            // Unreadable: let both commands run and report the parse error themselves.
+            return false;
+        }
+    }
     // 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 });
+        await guardProductionPush({
+            dryRun: this.dryRun,
+            error: (message) => this.error(message),
+            siteConfig: this.siteConfig,
+            yes: this.yes,
+        });
     }
 }

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

@@ -1,17 +1,24 @@
 import { LoopressCommand } from '../../lib/base.js';
+type SeoPullResult = {
+    path: string;
+    postTypes: string[];
+    status: 'dry-run' | 'success';
+};
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         'post-type': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<SeoPullResult>;
     private pullPostMeta;
     private pullRedirects;
     private pullSettings;
 }
+export {};

package/dist/commands/seo/pull.js

@@ -9,6 +9,7 @@ export default class Pull extends LoopressCommand {
         path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
     };
     static description = 'Pull SEO settings, post meta, and (if supported) redirects from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps seo pull', '$ lps seo pull --post-type post --post-type page'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -27,6 +28,7 @@ export default class Pull extends LoopressCommand {
             await this.pullPostMeta(postType, path);
         }
         await this.pullRedirects(path);
+        return { path, postTypes, status: this.dryRun ? 'dry-run' : 'success' };
     }
     async pullPostMeta(postType, basePath) {
         const dir = join(basePath, 'post-meta', postType);

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

@@ -1,9 +1,14 @@
 import { PushCommand } from '../../lib/push-command.js';
+type SeoPushResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+};
 export default class Push extends PushCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         'allow-external-redirects': import("@oclif/core/interfaces").BooleanFlag<boolean>;
@@ -11,7 +16,7 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     private allowExternalRedirects;
-    run(): Promise<void>;
+    run(): Promise<SeoPushResult>;
     private currentPostMetaRevision;
     private jsonFilesIn;
     private pushPostMeta;
@@ -21,3 +26,4 @@ export default class Push extends PushCommand {
     private pushSettings;
     private renameToCanonical;
 }
+export {};

package/dist/commands/seo/push.js

@@ -13,6 +13,7 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
     };
     static description = 'Push SEO settings, post meta, and redirects to WordPress. Local redirect files created remotely are renamed on disk to the `<id>-<slug>` convention. Fails clearly per file if the active SEO plugin does not support redirects.';
+    static enableJsonFlag = true;
     static examples = ['$ lps seo push', '$ lps seo push --allow-external-redirects'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -40,9 +41,10 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'SEO item')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { path, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All SEO configuration pushed.');
+        return { path, status: 'success' };
     }
     async currentPostMetaRevision(postType, slug) {
         try {

package/dist/commands/snippet/publish.js

@@ -14,7 +14,7 @@ export default class Publish extends Command {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
     };
     static description = 'Publish snippets to your Loopress account so they can be deployed to other projects. Does not touch any WordPress site.';
-    static examples = ['$ lps snippet publish', '$ lps snippet publish --path ./snippets'];
+    static examples = ['$ lps snippet publish', '$ lps snippet publish ./snippets'];
     async run() {
         const { args } = await this.parse(Publish);
         const { apiProjectId, localConfig, token } = await resolveLinkedProject((message) => this.error(message));

package/dist/commands/snippet/pull.js

@@ -19,7 +19,7 @@ export default class Pull extends LoopressCommand {
     };
     static description = 'Pull snippets from WordPress';
     static enableJsonFlag = true;
-    static examples = ['$ lps snippet pull', '$ lps snippet pull --path ./snippets'];
+    static examples = ['$ lps snippet pull', '$ lps snippet pull ./snippets'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,

package/dist/commands/snippet/push.js

@@ -15,7 +15,7 @@ export default class Push extends PushCommand {
     };
     static description = 'Push snippets to WordPress. Local snippet files created or updated remotely are renamed on disk to the `<id>-<slug>` convention.';
     static enableJsonFlag = true;
-    static examples = ['$ lps snippet push', '$ lps snippet push --path ./snippets'];
+    static examples = ['$ lps snippet push', '$ lps snippet push ./snippets'];
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,

package/dist/commands/status.d.ts

@@ -1,5 +1,6 @@
 import { Command } from '@oclif/core';
 type StatusInfo = {
+    environment?: string;
     environments?: string[];
     note?: string;
     project?: string;

package/dist/commands/status.js

@@ -37,7 +37,7 @@ export default class Status extends Command {
         }
         this.log(`Project:  ${project.name} (${env.name})`);
         this.log(`URL:      ${env.url}`);
-        return { project: `${project.name} (${env.name})`, url: env.url };
+        return { environment: env.name, project: `${project.name} (${env.name})`, url: env.url };
     }
     // Mirrors base.ts:resolveEnvironment with --env: the targeted project comes from
     // loopress.json when pinned, from the globally active project otherwise.
@@ -54,7 +54,7 @@ export default class Status extends Command {
         }
         this.log(`Project:  ${project.name} (${env.name}, via --env)`);
         this.log(`URL:      ${env.url}`);
-        return { project: `${project.name} (${env.name}, via --env)`, url: env.url };
+        return { environment: env.name, project: `${project.name} (${env.name}, via --env)`, url: env.url };
     }
     reportPinnedProject(projectId) {
         const project = configManager.getProject(projectId);
@@ -75,7 +75,7 @@ export default class Status extends Command {
             const env = project.environments[envNames[0]];
             this.log(`Project:  ${project.name} (${env.name})`);
             this.log(`URL:      ${env.url}`);
-            return { project: `${project.name} (${env.name})`, url: env.url };
+            return { environment: env.name, project: `${project.name} (${env.name})`, url: env.url };
         }
         const current = configManager.getCurrentProject();
         const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
@@ -93,6 +93,6 @@ export default class Status extends Command {
         }
         this.log(`Project:  ${project.name} (${currentEnv.name})`);
         this.log(`URL:      ${currentEnv.url}`);
-        return { project: `${project.name} (${currentEnv.name})`, url: currentEnv.url };
+        return { environment: currentEnv.name, project: `${project.name} (${currentEnv.name})`, url: currentEnv.url };
     }
 }

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

@@ -1,13 +1,11 @@
 import { LoopressCommand } from '../../lib/base.js';
+type PullTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pulled';
+};
 type PullResult = {
-    added: string[];
-    merged: Record<string, string>;
-    status: 'composer-managed' | 'dry-run' | 'success';
-    updated: Array<{
-        from: string;
-        slug: string;
-        to: string;
-    }>;
+    results: PullTargetResult[];
 };
 export default class Pull extends LoopressCommand {
     static description: string;

package/dist/commands/theme/pull.js

@@ -1,37 +1,41 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
-import { writeLocalConfig } from '../../utils/loopress-config.js';
-import { mergePluginManifest } from '../../utils/plugins.js';
-import { parseInstalledThemes } from '../../utils/themes.js';
+import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { pluralize } from '../../utils/pluralize.js';
+// Templates and parts have no pull: the child theme is written from the project, never read back.
+const PULL_TARGETS = [
+    { commandId: 'theme:version:pull', label: 'theme versions' },
+    { commandId: 'theme:style:pull', label: 'Global Styles' },
+];
 export default class Pull extends LoopressCommand {
-    static description = 'Pull installed themes from WordPress into loopress.json, pinned to their live versions';
+    static description = 'Pull everything theme related from WordPress: theme versions and Global Styles';
     static enableJsonFlag = true;
-    static examples = ['$ lps theme pull'];
+    static examples = ['$ lps theme pull', '$ lps theme pull --env staging', '$ lps theme pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
     };
     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. Run `lps composer pull` instead.');
-            return { added: [], merged: this.localConfig.themes ?? {}, status: 'composer-managed', updated: [] };
+        const argv = ['--env', this.siteConfig.name];
+        if (this.dryRun)
+            argv.push('--dry-run');
+        const results = [];
+        for (const target of PULL_TARGETS) {
+            this.log(`\n→ Pulling ${target.label}...`);
+            try {
+                await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand(target.commandId, argv));
+                this.log(`✓ ${target.label} pulled`);
+                results.push({ label: target.label, status: 'pulled' });
+            }
+            catch (error) {
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
+            }
         }
-        this.log(`Pulling themes from ${url}`);
-        const raw = await this.wp.get('wp/v2/themes');
-        const installed = parseInstalledThemes(raw);
-        const incoming = Object.fromEntries(installed.map((t) => [t.slug, t.version]));
-        const { added, merged, updated } = mergePluginManifest(this.localConfig.themes ?? {}, incoming);
-        if (this.dryRun) {
-            this.log(`[dry-run] Would write ${Object.keys(merged).length} themes to loopress.json`);
-            return { added, merged, status: 'dry-run', updated };
+        const failures = results.filter((result) => result.status === 'failed');
+        if (failures.length > 0) {
+            const reasons = failures.map((result) => `${result.label}: ${result.error}`);
+            this.error(`${pluralize(failures.length, 'theme resource')} failed to pull. ${reasons.join('; ')}`);
         }
-        await writeLocalConfig({ ...this.localConfig, themes: merged });
-        this.log(`Wrote ${Object.keys(merged).length} themes to loopress.json`);
-        if (added.length > 0)
-            this.log(`  + Added: ${added.join(', ')}`);
-        for (const u of updated)
-            this.log(`  ~ Updated: ${u.slug} ${u.from} → ${u.to}`);
-        return { added, merged, status: 'success', updated };
+        return { results };
     }
 }

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

@@ -1,11 +1,13 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { LoopressCommand } from '../../lib/base.js';
+type PushTargetResult = {
+    error?: string;
+    label: string;
+    status: 'failed' | 'pushed';
+};
 type PushResult = {
-    installed: string[];
-    pinned: string[];
-    removed: string[];
-    status: 'composer-managed' | 'dry-run' | 'in-sync' | 'success';
+    results: PushTargetResult[];
 };
-export default class Push extends PushCommand {
+export default class Push extends LoopressCommand {
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];
@@ -15,8 +17,5 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
-    private fetchInstanceLock;
-    private guardForce;
-    private sync;
 }
 export {};