@loopress/cli 0.22.0 → 0.24.0

package/dist/commands/plugin/push.js

@@ -1,98 +1,192 @@
-import { Listr } from 'listr2';
+import { Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { confirmUninstall } from '../../lib/interactive.js';
 import { PushCommand } from '../../lib/push-command.js';
-import { getComposerManagedSlugs, readComposerJson } from '../../utils/composer.js';
-import { diffPlugins, parseInstalledPlugins } from '../../utils/plugins.js';
-import { pluralize } from '../../utils/pluralize.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
+import { diffPlugins, lockedWpackagistSlugs, parseInstalledPlugins } from '../../utils/plugins.js';
+const IN_SYNC = { activated: [], installed: [], pinned: [], pruned: [], removed: [], status: 'in-sync' };
 export default class Push extends PushCommand {
-    static description = 'Push plugins to WordPress to match loopress.json';
+    static description = 'Install plugins on WordPress to match loopress.json, pinned via Composer + WPackagist';
     static enableJsonFlag = true;
-    static examples = ['$ lps plugin push', '$ lps plugin push --dry-run'];
+    static examples = ['$ lps plugin push', '$ lps plugin push --dry-run', '$ lps plugin push --force --prune'];
     static flags = {
         ...PushCommand.dryRunFlag,
         ...PushCommand.yesFlag,
+        force: Flags.boolean({
+            default: false,
+            description: 'Allow downgrades and let Loopress take over plugins installed outside it (replaces their files)',
+        }),
+        prune: Flags.boolean({
+            default: false,
+            description: 'Deactivate plugins that are active on the site but absent from loopress.json',
+        }),
     };
     async run() {
-        const { url } = this.siteConfig;
-        const manifest = this.localConfig.plugins;
-        if (!manifest || Object.keys(manifest).length === 0) {
-            this.error('No plugins found in loopress.json. Run `lps plugin pull` first.');
+        const { flags } = await this.parse(Push);
+        const { force, prune } = flags;
+        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 push` instead.');
+            return { ...IN_SYNC, status: 'composer-managed' };
         }
-        const composerJson = await readComposerJson();
-        const composerSlugs = composerJson ? getComposerManagedSlugs(composerJson) : [];
-        const filteredManifest = Object.fromEntries(Object.entries(manifest).filter(([slug]) => !composerSlugs.includes(slug)));
-        const skippedComposerManaged = composerSlugs.filter((slug) => Object.hasOwn(manifest, slug));
-        this.logSkippedComposerManaged(skippedComposerManaged);
-        this.log(`Pushing plugins to ${url}`);
+        const manifest = this.localConfig.plugins ?? {};
+        if (Object.keys(manifest).length === 0) {
+            this.error('No plugins found in loopress.json. Run `lps plugin pull` or `lps plugin add <slug>` first.');
+        }
+        this.log(`Pushing plugins to ${this.siteConfig.url}`);
         const raw = await this.wp.get('wp/v2/plugins');
         const installed = parseInstalledPlugins(raw);
-        const { toActivate, toInstall } = diffPlugins(filteredManifest, installed);
-        if (toInstall.length === 0 && toActivate.length === 0) {
+        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'plugin');
+        const diff = diffPlugins(manifest, installed, managed);
+        this.guardForce(diff, force);
+        const toPrune = prune ? diff.untrackedActive : [];
+        // A "latest" pin never shows as drift, but its newest upstream release may have moved
+        // since the last push, so a push must still run `composer update` to pick it up.
+        const hasLatestPin = Object.values(manifest).includes('latest');
+        if (!hasLatestPin && isNoop(diff, toPrune)) {
             this.log('Everything is already in sync.');
-            return { activated: [], installed: [], skippedComposerManaged, status: 'in-sync' };
+            return { ...IN_SYNC };
+        }
+        if (isNoop(diff, toPrune))
+            this.log('Refreshing plugins pinned to "latest" to their newest releases.');
+        logPlan(this, diff, toPrune, force);
+        if (this.dryRun) {
+            return this.result(diff, { includeCollisions: true, pruned: toPrune, removed: diff.toRemove, status: 'dry-run' });
         }
-        this.logPlannedChanges(toInstall, toActivate);
-        const installedSlugs = toInstall.map((a) => a.slug);
-        const activatedSlugs = toActivate.map((a) => a.slug);
-        if (this.dryRun)
-            return { activated: activatedSlugs, installed: installedSlugs, skippedComposerManaged, status: 'dry-run' };
-        // Installing with `status: active` activates in the same call, so installs never need a
-        // separate activation step the way the old custom endpoint's two-step flow did.
-        await this.applyPluginChanges(toInstall, toActivate);
-        if (this.failedCount > 0) {
-            this.error(`${pluralize(this.failedCount, 'plugin')} failed to install or activate.`);
+        if (!(await confirmUninstall(diff.toRemove, this.yes)))
+            this.error('Aborted.');
+        const deactivated = await this.deactivateEndangered(installed, diff, force);
+        // Plugins that must end up active: the ones we deactivated for the file swap (minus any
+        // being uninstalled) plus the ones the manifest wants active but that are inactive today.
+        const toReactivate = [...deactivated.filter((p) => !diff.toRemove.includes(p.slug)), ...diff.toActivate];
+        let response;
+        try {
+            response = await this.sync(manifest, force);
+        }
+        catch (error) {
+            // The file swap never happened, so restore the plugins we defensively deactivated
+            // instead of leaving the site with them switched off.
+            await this.activate(deactivated.filter((p) => !diff.toRemove.includes(p.slug)));
+            throw error;
         }
+        if (toPrune.length > 0) {
+            await this.deactivate(installed.filter((p) => toPrune.includes(p.slug)));
+        }
+        await this.activate(toReactivate);
+        if (response.output.trim())
+            this.log(response.output.trim());
+        this.log('Plugins synced.');
         await this.recordSuccess();
-        return { activated: activatedSlugs, installed: installedSlugs, skippedComposerManaged, status: 'success' };
-    }
-    async activatePlugin(file, slug, task) {
-        await this.performPluginAction('activate', slug, async () => this.wp.put(`wp/v2/plugins/${file}`, { status: 'active' }), task);
+        return this.result(diff, {
+            activated: toReactivate.map((p) => p.slug),
+            includeCollisions: force,
+            pruned: toPrune,
+            removed: response.removed ?? diff.toRemove,
+            status: 'success',
+        });
     }
-    async applyPluginChanges(toInstall, toActivate) {
-        if (toInstall.length > 0) {
-            await new Listr(toInstall.map((action) => ({
-                task: async (_ctx, task) => this.installPlugin(action.slug, task),
-                title: `Install ${action.slug}`,
-            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+    async activate(plugins) {
+        for (const plugin of plugins) {
+            this.log(`  ⊙ activating ${plugin.slug}`);
+            await this.wp.put(`wp/v2/plugins/${plugin.file}`, { status: 'active' });
         }
-        if (toActivate.length > 0) {
-            await new Listr(toActivate.map((action) => ({
-                task: async (_ctx, task) => this.activatePlugin(action.file, action.slug, task),
-                title: `Activate ${action.slug}`,
-            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+    }
+    async deactivate(plugins) {
+        for (const plugin of plugins) {
+            this.log(`  ⊘ deactivating ${plugin.slug}`);
+            await this.wp.put(`wp/v2/plugins/${plugin.file}`, { status: 'inactive' });
         }
     }
-    async installPlugin(slug, task) {
-        await this.performPluginAction('install', slug, async () => this.wp.post('wp/v2/plugins', { slug, status: 'active' }), task);
+    // Deactivate anything whose folder is about to be deleted or replaced (removed, re-pinned to
+    // a new version, or taken over with --force), so the site does not fatal in the window
+    // between removal and Composer finishing the install. Returns the plugins it switched off so
+    // the caller can switch the still-wanted ones back on.
+    async deactivateEndangered(installed, diff, force) {
+        const endangered = new Set([
+            ...diff.toRemove,
+            ...diff.toPin.map((p) => p.slug),
+            ...(force ? diff.collisions.map((c) => c.slug) : []),
+        ]);
+        const victims = installed.filter((p) => p.active && endangered.has(p.slug));
+        await this.deactivate(victims);
+        return victims;
     }
-    logPlannedChanges(toInstall, toActivate) {
-        if (toInstall.length > 0) {
-            this.log(`\nTo install (${toInstall.length}):`);
-            for (const a of toInstall)
-                this.log(`  + ${a.slug}`);
+    // The site's live composer.lock tells us which plugins Loopress already manages, so the plan
+    // can preview removals and tell an unmanaged folder (collision) apart from a re-pin. 404 =
+    // nothing pushed yet.
+    async fetchInstanceLock() {
+        try {
+            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+            return composerLock;
         }
-        if (toActivate.length > 0) {
-            this.log(`\nTo activate (${toActivate.length}):`);
-            for (const a of toActivate)
-                this.log(`  ↑ ${a.slug}`);
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
         }
     }
-    logSkippedComposerManaged(skippedComposerManaged) {
-        if (skippedComposerManaged.length === 0)
+    guardForce(diff, force) {
+        if (force)
             return;
-        this.log(`Skipping ${skippedComposerManaged.length} Composer-managed ${skippedComposerManaged.length === 1 ? 'plugin' : 'plugins'}: ${skippedComposerManaged.join(', ')}`);
-        this.log('Run `lps composer push` to deploy them.');
+        if (diff.collisions.length > 0) {
+            const list = diff.collisions.map((c) => `${c.slug} (${c.installedVersion})`).join(', ');
+            this.error(`${diff.collisions.length} plugin(s) are already installed outside Loopress: ${list}. ` +
+                'Re-run with --force to let Loopress manage them (this replaces their files with the WPackagist build, ' +
+                'local modifications are lost), or remove them from loopress.json.');
+        }
+        const downgrades = diff.toPin.filter((p) => isDowngrade(p.from, p.to));
+        if (downgrades.length > 0) {
+            const list = downgrades.map((p) => `${p.slug} ${p.from} to ${p.to}`).join(', ');
+            this.error(`Refusing to downgrade: ${list}. A downgrade only replaces plugin files, it does not undo database ` +
+                'migrations the newer version ran, which can break the site. Re-run with --force, or bump the version in loopress.json.');
+        }
+    }
+    result(diff, opts) {
+        const collisionSlugs = opts.includeCollisions ? diff.collisions.map((c) => c.slug) : [];
+        return {
+            activated: opts.activated ?? diff.toActivate.map((a) => a.slug),
+            installed: [...diff.toInstall.map((a) => a.slug), ...collisionSlugs],
+            pinned: diff.toPin.map((p) => p.slug),
+            pruned: opts.pruned,
+            removed: opts.removed,
+            status: opts.status,
+        };
     }
-    async performPluginAction(verb, slug, request, task) {
+    async sync(manifest, force) {
         try {
-            await request();
-            const message = `✓ ${slug} ${verb === 'install' ? 'installed and activated' : 'activated'}`;
-            if (task)
-                task.output = message;
-            else
-                this.log(`  ${message}`);
+            return await this.wp.post('loopress/v1/composer/sync', { force, intent: { plugins: manifest }, lock: null }, { timeoutMs: SYNC_TIMEOUT_MS });
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to ${verb} ${slug}: ${error.message}`, error, task);
+            const collisions = parseCollisions(error);
+            if (collisions) {
+                this.error(`The site rejected the push: ${collisions.map((c) => c.slug).join(', ')} installed outside Loopress. Re-run with --force.`);
+            }
+            throw error;
         }
     }
 }
+function isNoop(diff, toPrune) {
+    return (diff.toInstall.length === 0 &&
+        diff.toPin.length === 0 &&
+        diff.toActivate.length === 0 &&
+        diff.toRemove.length === 0 &&
+        diff.collisions.length === 0 &&
+        toPrune.length === 0);
+}
+function logPlan(cmd, diff, prune, force) {
+    const section = (label, lines) => {
+        if (lines.length === 0)
+            return;
+        cmd.log(`\n${label} (${lines.length}):`);
+        for (const line of lines)
+            cmd.log(`  ${line}`);
+    };
+    section('To install', diff.toInstall.map((a) => `+ ${a.slug} ${a.version}`));
+    if (force)
+        section('To take over', diff.collisions.map((c) => `! ${c.slug} (installed outside Loopress)`));
+    section('To re-pin', diff.toPin.map((p) => `~ ${p.slug} ${p.from} to ${p.to}`));
+    section('To activate', diff.toActivate.map((a) => `↑ ${a.slug}`));
+    section('To uninstall', diff.toRemove.map((s) => `- ${s}`));
+    section('To deactivate (--prune)', prune.map((s) => `⊘ ${s}`));
+}

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

@@ -0,0 +1,22 @@
+import { LoopressCommand } from '../../lib/base.js';
+type StatusResult = {
+    drift: boolean;
+    inactive: string[];
+    missing: string[];
+    status: 'composer-managed' | 'drift' | 'in-sync';
+    untrackedActive: string[];
+    wrongVersion: Array<{
+        live: string;
+        pinned: string;
+        slug: string;
+    }>;
+};
+export default class Status extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<StatusResult>;
+    private fetchInstanceLock;
+}
+export {};

package/dist/commands/plugin/status.js

@@ -0,0 +1,65 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { diffPlugins, lockedWpackagistSlugs, parseInstalledPlugins } from '../../utils/plugins.js';
+export default class Status extends LoopressCommand {
+    static description = 'Compare the plugins on WordPress against loopress.json and report drift';
+    static enableJsonFlag = true;
+    static examples = ['$ lps plugin status'];
+    static flags = {};
+    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` commands instead.');
+            return { drift: false, inactive: [], missing: [], status: 'composer-managed', untrackedActive: [], wrongVersion: [] };
+        }
+        const manifest = this.localConfig.plugins ?? {};
+        const raw = await this.wp.get('wp/v2/plugins');
+        const installed = parseInstalledPlugins(raw);
+        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'plugin');
+        const diff = diffPlugins(manifest, installed, managed);
+        const missing = diff.toInstall.map((a) => a.slug);
+        const wrongVersion = diff.toPin.map((p) => ({ live: p.from, pinned: p.to, slug: p.slug }));
+        const inactive = diff.toActivate.map((a) => a.slug);
+        const { untrackedActive } = diff;
+        // `collisions` are also drift (Loopress doesn't own them yet); surface them under missing's
+        // banner so `plugin push --force` is the obvious next step.
+        const collisions = diff.collisions.map((c) => c.slug);
+        const drift = missing.length > 0 ||
+            wrongVersion.length > 0 ||
+            inactive.length > 0 ||
+            diff.toRemove.length > 0 ||
+            collisions.length > 0;
+        if (!drift && untrackedActive.length === 0) {
+            this.log(`In sync with loopress.json (${url})`);
+            return { drift: false, inactive: [], missing: [], status: 'in-sync', untrackedActive: [], wrongVersion: [] };
+        }
+        if (missing.length > 0)
+            this.log(`Not installed: ${missing.join(', ')}`);
+        if (collisions.length > 0)
+            this.log(`Installed outside Loopress (run \`plugin push --force\`): ${collisions.join(', ')}`);
+        for (const w of wrongVersion)
+            this.log(`Version drift: ${w.slug} is ${w.live}, loopress.json pins ${w.pinned}`);
+        if (inactive.length > 0)
+            this.log(`Pinned but inactive: ${inactive.join(', ')}`);
+        if (diff.toRemove.length > 0)
+            this.log(`Managed by Loopress but dropped from loopress.json: ${diff.toRemove.join(', ')}`);
+        if (untrackedActive.length > 0)
+            this.log(`Active but untracked: ${untrackedActive.join(', ')}`);
+        if (drift)
+            this.exit(1);
+        return { drift, inactive, missing, status: drift ? 'drift' : 'in-sync', untrackedActive, wrongVersion };
+    }
+    async fetchInstanceLock() {
+        try {
+            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+            return composerLock;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+    }
+}

package/dist/commands/pull.js

@@ -8,13 +8,14 @@ const PULL_TARGETS = [
     { commandId: 'plugin:pull', label: 'plugins' },
     { commandId: 'acf:pull', label: 'ACF', supportsYes: true },
     { commandId: 'api:pull', label: 'API routes', supportsYes: true },
+    { commandId: 'hook:pull', label: 'hooks', supportsYes: true },
     { commandId: 'form:pull', label: 'forms', supportsYes: true },
-    { commandId: 'page:pull', label: 'pages', supportsYes: true },
     { commandId: 'seo:pull', label: 'SEO', 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, forms, pages, SEO, and snippets, from WordPress';
+    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, from WordPress';
     static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,

package/dist/commands/push.js

@@ -8,13 +8,14 @@ const PUSH_TARGETS = [
     { commandId: 'composer:push', label: 'composer' },
     { commandId: 'acf:push', label: 'ACF' },
     { commandId: 'api:push', label: 'API routes' },
+    { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
-    { commandId: 'page:push', label: 'pages' },
     { commandId: 'seo:push', label: 'SEO' },
+    { 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, forms, pages, SEO, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, options, and snippets, to WordPress';
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -42,7 +43,7 @@ export default class Push extends LoopressCommand {
     }
     // 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.
+    // Without this, each delegated command would re-run its own production guard.
     buildArgv() {
         const argv = ['--env', this.siteConfig.name, '--yes'];
         if (this.dryRun)

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

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

package/dist/commands/seo/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('seo', {
+    description: 'Show what differs in SEO settings, post meta, and redirects between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'SEO directory',
+});

package/dist/commands/snippet/diff.d.ts

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

package/dist/commands/snippet/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('snippet', {
+    description: 'Show what differs in snippets between your local files and a WordPress environment, or between two environments',
+    pathNoun: 'snippets directory',
+});

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

@@ -0,0 +1,13 @@
+import { LoopressCommand } from '../../lib/base.js';
+export default class Add extends LoopressCommand {
+    static args: {
+        slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    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/theme/add.js

@@ -0,0 +1,35 @@
+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: 'Theme slug on WordPress.org', required: true }),
+    };
+    static description = 'Add a WordPress.org theme to loopress.json';
+    static examples = ['$ lps theme add generatepress', '$ lps theme add generatepress --version 3.4.0'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        version: Flags.string({ description: 'Exact version to pin (default: "latest")' }),
+    };
+    async run() {
+        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 3.4.0, not a Composer constraint. Got "${version}".`);
+        }
+        const existing = this.localConfig.themes ?? {};
+        if (existing[slug] === version) {
+            this.log(`${slug} is already pinned to ${version}, nothing to do.`);
+            return;
+        }
+        const isUpdated = existing[slug] !== undefined;
+        if (this.dryRun) {
+            this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version})`);
+            return;
+        }
+        await writeLocalConfig({ ...this.localConfig, themes: { ...existing, [slug]: version } });
+        this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps theme push\` to apply.`);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { LoopressCommand } from '../../lib/base.js';
+type PullResult = {
+    added: string[];
+    merged: Record<string, string>;
+    status: 'composer-managed' | 'dry-run' | 'success';
+    updated: Array<{
+        from: string;
+        slug: string;
+        to: string;
+    }>;
+};
+export default class Pull extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<PullResult>;
+}
+export {};

package/dist/commands/theme/pull.js

@@ -0,0 +1,37 @@
+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';
+export default class Pull extends LoopressCommand {
+    static description = 'Pull installed themes from WordPress into loopress.json, pinned to their live versions';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme pull'];
+    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: [] };
+        }
+        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 };
+        }
+        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 };
+    }
+}

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

@@ -0,0 +1,22 @@
+import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    installed: string[];
+    pinned: 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>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<PushResult>;
+    private fetchInstanceLock;
+    private guardForce;
+    private sync;
+}
+export {};