@loopress/cli 0.22.0 → 0.24.0

package/dist/commands/option/pull.js

@@ -0,0 +1,75 @@
+import { Args } from '@oclif/core';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { loadFiles } from '../../lib/load-files.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { optionEndpoint, optionFileName, parseLocalOption } from '../../utils/option-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    static description = 'Refresh locally tracked options from WordPress. Options not yet tracked are never pulled, run `lps option add <name>` for those first.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const dir = this.resolveOptionsPath(args.path);
+        const { url } = this.siteConfig;
+        this.log(`Pulling tracked options from ${url}`);
+        this.log(`Options path: ${dir}`);
+        const tracked = await loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => {
+                this.warn(message);
+            },
+            parse: parseLocalOption,
+        });
+        if (tracked.length === 0) {
+            this.log('Nothing tracked locally. Run `lps option add <name>` first.');
+            return [];
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would refresh ${pluralize(tracked.length, 'option')}: ${tracked.map((option) => option.name).join(', ')}`);
+            return tracked;
+        }
+        const refreshed = [];
+        const orphans = [];
+        for (const option of tracked) {
+            const result = await this.pullOption(dir, option);
+            if (result === null) {
+                orphans.push(optionFileName(option.name));
+            }
+            else {
+                refreshed.push(result);
+                this.log(`Pulled: ${option.name}`);
+            }
+        }
+        await this.removeOrphanedFiles(dir, orphans, 'no longer exist on WordPress');
+        this.log(`Pulled ${pluralize(refreshed.length, 'option')}`);
+        return refreshed;
+    }
+    // Returns the refreshed option (and writes it to disk), or null when the tracked name is a
+    // 404 on this environment: absent, not a failure (see the orphan reconciliation in run()).
+    // readonly is a local policy flag with no WordPress counterpart, always preserved from the
+    // existing file rather than overwritten by the pulled value.
+    async pullOption(dir, option) {
+        let remote;
+        try {
+            remote = await this.wp.get(optionEndpoint(option.name));
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+        const local = { ...remote, readonly: option.readonly };
+        await writeFile(join(dir, optionFileName(option.name)), JSON.stringify(local, null, 2) + '\n');
+        return local;
+    }
+}

package/dist/commands/{page → option}/push.d.ts

@@ -1,10 +1,7 @@
 import { PushCommand } from '../../lib/push-command.js';
-type PushedPage = {
-    id: null | number;
-    title: string;
-};
 type PushResult = {
-    pushed: PushedPage[];
+    pushed: string[];
+    skipped: string[];
     status: 'dry-run' | 'success';
 };
 export default class Push extends PushCommand {
@@ -19,8 +16,6 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
-    private ensureCanonicalFilename;
-    private loadFiles;
-    private pushPage;
+    private pushOption;
 }
 export {};

package/dist/commands/option/push.js

@@ -0,0 +1,66 @@
+import { Args } from '@oclif/core';
+import { loadFiles } from '../../lib/load-files.js';
+import { PushCommand } from '../../lib/push-command.js';
+import { optionEndpoint, parseLocalOption, partitionByReadonly } from '../../utils/option-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    static description = 'Push locally tracked, non-readonly options to WordPress (upsert only, never deletes an untracked option). ' +
+        'Options marked "readonly": true in their local file are skipped, edit the file to override.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const dir = this.resolveOptionsPath(args.path);
+        const { url } = this.siteConfig;
+        this.log(`Pushing tracked options to ${url}`);
+        this.log(`Options path: ${dir}`);
+        const tracked = await loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => {
+                this.warn(message);
+            },
+            parse: parseLocalOption,
+        });
+        const { skipped, writable } = partitionByReadonly(tracked);
+        if (skipped.length > 0) {
+            this.log(`Skipping ${pluralize(skipped.length, 'readonly option')}: ${skipped.map((option) => option.name).join(', ')}`);
+        }
+        this.log(`Found ${pluralize(writable.length, 'option')} to push`);
+        const pushed = [];
+        await this.runPushTasks(writable, (option) => option.name, async (option, task) => {
+            await this.pushOption(option, task);
+            pushed.push(option.name);
+        });
+        if (this.failedCount > 0) {
+            this.error(`${pluralize(this.failedCount, 'option')} failed to push.`);
+        }
+        const skippedNames = skipped.map((option) => option.name);
+        if (this.dryRun)
+            return { pushed, skipped: skippedNames, status: 'dry-run' };
+        await this.recordSuccess();
+        this.log('All options pushed.');
+        return { pushed, skipped: skippedNames, status: 'success' };
+    }
+    async pushOption(option, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${option.name}`;
+            return;
+        }
+        try {
+            await this.wp.put(optionEndpoint(option.name), { autoload: option.autoload, value: option.value });
+            if (task)
+                task.output = `Pushed: ${option.name}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${option.name}: ${error.message}`, error, task);
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import { LoopressCommand } from '../../lib/base.js';
+type RemoveResult = {
+    deletedRemote: boolean;
+    name: string;
+    status: 'aborted' | 'dry-run' | 'success';
+};
+export default class Remove extends LoopressCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'local-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        path: 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<RemoveResult>;
+}
+export {};

package/dist/commands/option/remove.js

@@ -0,0 +1,69 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { optionEndpoint, optionFileName } from '../../utils/option-format.js';
+export default class Remove extends LoopressCommand {
+    static args = {
+        name: Args.string({ description: 'Option name to stop tracking', required: true }),
+    };
+    static description = 'Stop tracking an option locally and delete it from WordPress. Local untracking always happens (git-reversible); ' +
+        'pass --local-only to skip the WordPress delete and only stop tracking.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps option remove wpseo_titles', '$ lps option remove wpseo_titles --local-only'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+        'local-only': Flags.boolean({ description: 'Untrack locally without deleting the option on WordPress' }),
+        path: Flags.string({ description: 'Path to options directory (overrides project config)' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Remove);
+        const { name } = args;
+        const dir = this.resolveOptionsPath(flags.path);
+        const { url } = this.siteConfig;
+        const file = join(dir, optionFileName(name));
+        const localOnly = flags['local-only'];
+        if (this.dryRun) {
+            const andDelete = localOnly ? '' : ` and delete it from ${url}`;
+            this.log(`[dry-run] Would untrack "${name}" locally${andDelete}`);
+            return { deletedRemote: false, name, status: 'dry-run' };
+        }
+        if (localOnly) {
+            await rm(file, { force: true });
+            this.log(`Untracked "${name}" locally (left untouched on ${url})`);
+            return { deletedRemote: false, name, status: 'success' };
+        }
+        await guardProductionPush({
+            dryRun: this.dryRun,
+            error: (message) => this.error(message),
+            siteConfig: this.siteConfig,
+            yes: this.yes,
+        });
+        if (!this.yes && isInteractive()) {
+            const isProceed = await confirm({ default: false, message: `Delete option "${name}" from ${url}? (local tracking also stops)` });
+            if (!isProceed) {
+                this.log('Aborted.');
+                return { deletedRemote: false, name, status: 'aborted' };
+            }
+        }
+        let deletedRemote = true;
+        try {
+            await this.wp.delete(optionEndpoint(name));
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+            deletedRemote = false;
+        }
+        await rm(file, { force: true });
+        this.log(deletedRemote
+            ? `Removed "${name}" from ${url} and untracked it locally`
+            : `"${name}" was already absent on ${url}; untracked it locally`);
+        return { deletedRemote, name, status: 'success' };
+    }
+}

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

@@ -6,6 +6,7 @@ export default class Add extends LoopressCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/plugin/add.js

@@ -1,32 +1,42 @@
-import { Args } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { LoopressCommand } from '../../lib/base.js';
 import { writeLocalConfig } from '../../utils/loopress-config.js';
+import { isExactVersion } from '../../utils/version.js';
 export default class Add extends LoopressCommand {
     static args = {
         slug: Args.string({ description: 'Plugin slug on WordPress.org', required: true }),
     };
     static description = 'Add a WordPress.org plugin to loopress.json';
-    static examples = ['$ lps plugin add woocommerce', '$ lps plugin add contact-form-7 --dry-run'];
+    static examples = [
+        '$ lps plugin add woocommerce',
+        '$ lps plugin add woocommerce --version 9.4.2',
+        '$ lps plugin add contact-form-7 --dry-run',
+    ];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        version: Flags.string({ description: 'Exact version to pin (default: "latest", tracked on every push)' }),
     };
     async run() {
-        const { args } = await this.parse(Add);
+        const { args, flags } = await this.parse(Add);
         const { slug } = args;
+        const version = flags.version ?? 'latest';
+        if (version !== 'latest' && !isExactVersion(version)) {
+            this.error(`--version must be an exact version like 9.4.2, not a Composer constraint. Got "${version}".`);
+        }
         const existing = this.localConfig.plugins ?? {};
-        if (existing[slug] === 'latest') {
-            this.log(`${slug} is already in loopress.json, nothing to do.`);
+        if (existing[slug] === version) {
+            this.log(`${slug} is already pinned to ${version} in loopress.json, nothing to do.`);
             return;
         }
         const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
-            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} in loopress.json`);
+            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version}) in loopress.json`);
             return;
         }
         await writeLocalConfig({
             ...this.localConfig,
-            plugins: { ...existing, [slug]: 'latest' },
+            plugins: { ...existing, [slug]: version },
         });
-        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug}`);
+        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps plugin push\` to apply.`);
     }
 }

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

@@ -0,0 +1,30 @@
+import { LoopressCommand } from '../../lib/base.js';
+type Advisory = {
+    cve?: string;
+    fixedIn?: string;
+    score?: number;
+    severity?: string;
+    slug: string;
+    title: string;
+};
+type HealthNote = {
+    message: string;
+    slug: string;
+};
+type AuditResult = {
+    advisories: Advisory[];
+    health: HealthNote[];
+    status: 'clean' | 'issues';
+};
+export default class Audit extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<AuditResult>;
+    private auditOne;
+    private fetchHealth;
+    private fetchVulnerabilities;
+    private report;
+}
+export {};

package/dist/commands/plugin/audit.js

@@ -0,0 +1,138 @@
+import got from 'got';
+import { LoopressCommand } from '../../lib/base.js';
+import { compareVersions } from '../../utils/version.js';
+const WPVULN_BASE = 'https://www.wpvulnerability.net/plugin';
+const WPORG_INFO = 'https://api.wordpress.org/plugins/info/1.2/';
+export default class Audit extends LoopressCommand {
+    static description = 'Check the plugins in loopress.json for known vulnerabilities and health issues';
+    static enableJsonFlag = true;
+    static examples = ['$ lps plugin audit'];
+    static flags = {};
+    async run() {
+        const manifest = { ...this.localConfig.plugins };
+        const slugs = Object.keys(manifest);
+        if (slugs.length === 0) {
+            this.log('No plugins in loopress.json to audit.');
+            return { advisories: [], health: [], status: 'clean' };
+        }
+        const advisories = [];
+        const health = [];
+        for (const slug of slugs) {
+            const found = await this.auditOne(slug, manifest[slug]);
+            advisories.push(...found.advisories);
+            health.push(...found.health);
+        }
+        return this.report(advisories, health, slugs.length);
+    }
+    async auditOne(slug, pinned) {
+        const [vulns, info] = await Promise.all([this.fetchVulnerabilities(slug), this.fetchHealth(slug)]);
+        const advisories = vulns
+            .filter((v) => pinned === 'latest' || affects(pinned, v.fixedIn))
+            .map((v) => ({ ...v, slug }));
+        const health = info ? describeHealth(slug, pinned, info) : [];
+        return { advisories, health };
+    }
+    async fetchHealth(slug) {
+        try {
+            const body = await got(WPORG_INFO, {
+                searchParams: { 'action': 'plugin_information', 'request[slug]': slug },
+                timeout: { request: 10_000 },
+            }).json();
+            return typeof body === 'object' && !('error' in body) ? body : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async fetchVulnerabilities(slug) {
+        let body;
+        try {
+            body = await got(`${WPVULN_BASE}/${encodeURIComponent(slug)}/`, {
+                timeout: { request: 10_000 },
+            }).json();
+        }
+        catch (error) {
+            // Never swallow this into an empty list: a clean audit must mean "no advisories found",
+            // not "the advisory service was unreachable". Fail the command instead.
+            throw new Error(`Could not reach the vulnerability database (wpvulnerability.net) for "${slug}": ${error.message}. ` +
+                'Audit aborted so a service outage is not reported as a clean result.', { cause: error });
+        }
+        const list = Array.isArray(body?.data?.vulnerability) ? body.data.vulnerability : [];
+        return list.map((raw) => normalizeAdvisory(raw));
+    }
+    report(advisories, health, count) {
+        if (advisories.length === 0 && health.length === 0) {
+            this.log(`No known vulnerabilities or health issues for ${count} plugin(s).`);
+            return { advisories, health, status: 'clean' };
+        }
+        for (const a of advisories)
+            this.log(`  ⚠ ${a.slug}: ${a.title}${advisoryMeta(a)}`);
+        for (const h of health)
+            this.log(`  · ${h.slug}: ${h.message}`);
+        const noun = advisories.length === 1 ? 'advisory' : 'advisories';
+        this.log(`\n${advisories.length} vulnerability ${noun}, ${health.length} health note(s). ` +
+            'Vulnerability data: wpvulnerability.net.');
+        if (advisories.length > 0)
+            this.exit(1);
+        return { advisories, health, status: 'issues' };
+    }
+}
+function advisoryMeta(a) {
+    const fixed = a.fixedIn ? `fixed in ${a.fixedIn}` : undefined;
+    const parts = [a.severity, a.cve, fixed].filter(Boolean);
+    return parts.length > 0 ? ` (${parts.join(', ')})` : '';
+}
+function normalizeAdvisory(raw) {
+    const cvss = (raw.cvss ?? {});
+    const source = Array.isArray(raw.source) ? raw.source : [];
+    const cve = typeof raw.cve === 'string' ? raw.cve : source.find((s) => s.id?.startsWith('CVE-'))?.id;
+    return {
+        cve,
+        fixedIn: extractFixedIn(raw),
+        score: cvss.score,
+        severity: cvss.severity,
+        title: typeof raw.name === 'string' ? raw.name : 'Unnamed advisory',
+    };
+}
+// wpvulnerability's `impact.software[].versions[]` carries `to_version` / `to_compare`; the
+// first "< X" bound is the version the fix landed in. Best-effort: the shape varies, so a
+// missing bound just means we can't tell and the advisory is reported anyway.
+function extractFixedIn(raw) {
+    const impact = raw.impact;
+    for (const sw of impact?.software ?? []) {
+        for (const v of sw.versions ?? []) {
+            if (v.to_compare === '<' && typeof v.to_version === 'string')
+                return v.to_version;
+        }
+    }
+    return undefined;
+}
+// If we know the fix version, a pin below it is affected. If we can't compare (odd version
+// strings), report it anyway: a false positive is safer than hiding an advisory.
+function affects(pinned, fixedIn) {
+    if (!fixedIn)
+        return true;
+    const order = compareVersions(pinned, fixedIn);
+    return order === null || order < 0;
+}
+function describeHealth(slug, pinned, info) {
+    const notes = [];
+    if (info.closed === true) {
+        notes.push({ message: 'removed from the WordPress.org directory', slug });
+    }
+    const requiresPhp = typeof info.requires_php === 'string' ? info.requires_php : null;
+    if (requiresPhp)
+        notes.push({ message: `requires PHP ${requiresPhp}`, slug });
+    const latest = typeof info.version === 'string' ? info.version : null;
+    const behindLatest = latest ? compareVersions(pinned, latest) : null;
+    if (latest && pinned !== 'latest' && behindLatest !== null && behindLatest < 0) {
+        notes.push({ message: `pinned to ${pinned}, latest is ${latest}`, slug });
+    }
+    const lastUpdated = typeof info.last_updated === 'string' ? info.last_updated : null;
+    if (lastUpdated) {
+        const years = (Date.now() - Date.parse(lastUpdated)) / (365 * 24 * 3600 * 1000);
+        if (years > 2)
+            notes.push({ message: `last updated ${lastUpdated.slice(0, 10)} (possibly abandoned)`, slug });
+    }
+    return notes;
+}

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

@@ -1,7 +1,7 @@
 import { LoopressCommand } from '../../lib/base.js';
 import { type MergeResult } from '../../utils/plugins.js';
 type PullResult = MergeResult & {
-    status: 'dry-run' | 'success';
+    status: 'composer-managed' | 'dry-run' | 'success';
 };
 export default class Pull extends LoopressCommand {
     static description: string;
@@ -11,6 +11,5 @@ export default class Pull extends LoopressCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PullResult>;
-    private logSkippedComposerManaged;
 }
 export {};

package/dist/commands/plugin/pull.js

@@ -1,9 +1,10 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
-import { getComposerManagedSlugs, readComposerJson } from '../../utils/composer.js';
 import { writeLocalConfig } from '../../utils/loopress-config.js';
 import { mergePluginManifest, parseInstalledPlugins } from '../../utils/plugins.js';
 export default class Pull extends LoopressCommand {
-    static description = 'Pull installed plugins from WordPress into loopress.json';
+    static description = 'Pull installed plugins from WordPress into loopress.json, pinned to their live versions';
     static enableJsonFlag = true;
     static examples = ['$ lps plugin pull', '$ lps plugin pull --dry-run'];
     static flags = {
@@ -11,13 +12,17 @@ export default class Pull extends LoopressCommand {
     };
     async run() {
         const { url } = this.siteConfig;
+        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
+            this.warn('This project has a composer.json, which is authoritative for plugins. Run `lps composer pull` instead.');
+            return { added: [], merged: this.localConfig.plugins ?? {}, status: 'composer-managed', updated: [] };
+        }
         this.log(`Pulling plugins from ${url}`);
         const raw = await this.wp.get('wp/v2/plugins');
         const installed = parseInstalledPlugins(raw);
-        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']));
-        this.logSkippedComposerManaged(installed.filter((p) => composerSlugs.includes(p.slug)).map((p) => p.slug));
+        // Pin every plugin to the version actually running on the site. A later `plugin push`
+        // installs exactly this set via Composer + WPackagist; drift only surfaces when the pinned
+        // version and the live version disagree.
+        const incoming = Object.fromEntries(installed.map((p) => [p.slug, p.version]));
         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`);
@@ -35,9 +40,4 @@ 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

@@ -2,23 +2,28 @@ import { PushCommand } from '../../lib/push-command.js';
 type PushResult = {
     activated: string[];
     installed: string[];
-    skippedComposerManaged: string[];
-    status: 'dry-run' | 'in-sync' | 'success';
+    pinned: string[];
+    pruned: string[];
+    removed: string[];
+    status: 'composer-managed' | 'dry-run' | 'in-sync' | 'success';
 };
 export default class Push extends PushCommand {
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        prune: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
-    private activatePlugin;
-    private applyPluginChanges;
-    private installPlugin;
-    private logPlannedChanges;
-    private logSkippedComposerManaged;
-    private performPluginAction;
+    private activate;
+    private deactivate;
+    private deactivateEndangered;
+    private fetchInstanceLock;
+    private guardForce;
+    private result;
+    private sync;
 }
 export {};