@loopress/cli 0.27.0 → 0.29.0

package/dist/commands/theme/push.js

@@ -1,123 +1,66 @@
 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 { isNotFoundError } from '../../lib/wp-client.js';
-import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
-import { lockedWpackagistSlugs } from '../../utils/plugins.js';
-import { diffThemes, parseInstalledThemes } from '../../utils/themes.js';
-const IN_SYNC = { installed: [], pinned: [], removed: [], status: 'in-sync' };
-export default class Push extends PushCommand {
-    static description = 'Install themes on WordPress to match loopress.json (versions only, never switches the active theme)';
+import { LoopressCommand } from '../../lib/base.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { pluralize } from '../../utils/pluralize.js';
+// The parent theme must be installed before its child theme is written, and Global Styles
+// belong to whichever theme is active, so they go last.
+const PUSH_TARGETS = [
+    { commandId: 'theme:version:push', label: 'theme versions' },
+    { commandId: 'theme:template:push', label: 'templates and parts' },
+    { commandId: 'theme:style:push', label: 'Global Styles' },
+];
+export default class Push extends LoopressCommand {
+    static description = 'Push everything theme related to WordPress: theme versions, templates and parts, then Global Styles';
     static enableJsonFlag = true;
-    static examples = ['$ lps theme push', '$ lps theme push --force'];
+    static examples = ['$ lps theme push', '$ lps theme push --env staging', '$ lps theme push --dry-run'];
     static flags = {
-        ...PushCommand.dryRunFlag,
-        ...PushCommand.yesFlag,
-        force: Flags.boolean({ default: false, description: 'Allow downgrades and take over themes installed outside Loopress' }),
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+        force: Flags.boolean({ default: false, description: 'Passed to `lps theme version push`' }),
     };
     async run() {
         const { flags } = await this.parse(Push);
-        const { force } = flags;
-        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
-            this.warn('This project has a composer.json, which is authoritative. Run `lps composer push` instead.');
-            return { ...IN_SYNC, status: 'composer-managed' };
-        }
-        const manifest = this.localConfig.themes ?? {};
-        if (Object.keys(manifest).length === 0) {
-            this.error('No themes found in loopress.json. Run `lps theme pull` first.');
-        }
-        this.log(`Pushing themes to ${this.siteConfig.url}`);
-        const raw = await this.wp.get('wp/v2/themes');
-        const installed = parseInstalledThemes(raw);
-        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'theme');
-        const diff = diffThemes(manifest, installed, managed);
-        this.guardForce(diff, force);
-        // Uninstalling the theme WordPress is currently rendering leaves the site with no active
-        // theme, which is a hard fatal. --force does not override this: switch the active theme
-        // on the site first, then the removal is safe. A --force takeover of a collision hits the
-        // same fatal: the server moves the existing folder out of the way before reinstalling it,
-        // so the active theme is briefly missing either way, an active collision is just as
-        // dangerous as an active removal.
-        const activeRemoval = [...diff.toRemove, ...diff.collisions.map((c) => c.slug)].find((slug) => installed.find((t) => t.slug === slug)?.active);
-        if (activeRemoval) {
-            this.error(`Refusing to uninstall "${activeRemoval}": it is the site's active theme. ` +
-                'Switch the site to another theme, then re-run to remove it.');
-        }
-        // A "latest" pin never shows as drift, but its newest upstream release may have moved, so
-        // a push must still run `composer update` to pick it up.
-        const hasLatestPin = Object.values(manifest).includes('latest');
-        if (!hasLatestPin && isNoop(diff)) {
-            this.log('Everything is already in sync.');
-            return { ...IN_SYNC };
-        }
-        if (isNoop(diff))
-            this.log('Refreshing themes pinned to "latest" to their newest releases.');
-        for (const a of diff.toInstall)
-            this.log(`  + ${a.slug} ${a.version}`);
-        for (const p of diff.toPin)
-            this.log(`  ~ ${p.slug} ${p.from} to ${p.to}`);
-        for (const s of diff.toRemove)
-            this.log(`  - ${s}`);
-        for (const c of diff.collisions)
-            this.log(`  ! ${c.slug} (take over)`);
-        if (this.dryRun)
-            return result(diff, 'dry-run', diff.toRemove, true);
-        if (!(await confirmUninstall(diff.toRemove, this.yes)))
-            this.error('Aborted.');
-        const response = await this.sync(manifest, force);
-        if (response.output.trim())
-            this.log(response.output.trim());
-        this.log('Themes synced.');
-        await this.recordSuccess();
-        return result(diff, 'success', response.removed ?? diff.toRemove, force);
-    }
-    async fetchInstanceLock() {
-        try {
-            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
-            return composerLock;
-        }
-        catch (error) {
-            if (isNotFoundError(error))
-                return null;
-            throw error;
-        }
-    }
-    guardForce(diff, force) {
-        if (force)
-            return;
-        if (diff.collisions.length > 0) {
-            const list = diff.collisions.map((c) => `${c.slug} (${c.installedVersion})`).join(', ');
-            this.error(`${list} installed outside Loopress. Re-run with --force to take them over, 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}. Re-run with --force.`);
-        }
-    }
-    async sync(manifest, force) {
-        try {
-            return await this.wp.post('loopress/v1/composer/sync', { force, intent: { themes: manifest }, lock: null }, { timeoutMs: SYNC_TIMEOUT_MS });
-        }
-        catch (error) {
-            if (parseCollisions(error)) {
-                this.error('The site rejected the push: themes installed outside Loopress. Re-run with --force.');
+        // Guarded once here, like `lps push`. Steps get --production-confirmed rather than --yes,
+        // so the versions step still asks before uninstalling themes unless the user passed --yes.
+        await guardProductionPush({
+            dryRun: this.dryRun,
+            error: (message) => this.error(message),
+            siteConfig: this.siteConfig,
+            yes: this.yes,
+        });
+        // Nothing to install and no composer.json: the versions step would only fail on an empty
+        // manifest, which must not fail a templates or styles only project.
+        const hasVersions = Object.keys(this.localConfig.themes ?? {}).length > 0 || existsSync(join(process.cwd(), this.rootDir, 'composer.json'));
+        const targets = hasVersions ? PUSH_TARGETS : PUSH_TARGETS.filter((target) => target.commandId !== 'theme:version:push');
+        const results = [];
+        for (const target of targets) {
+            const argv = ['--env', this.siteConfig.name, '--production-confirmed'];
+            if (this.yes)
+                argv.push('--yes');
+            if (this.dryRun)
+                argv.push('--dry-run');
+            if (flags.force && target.commandId === 'theme:version:push')
+                argv.push('--force');
+            this.log(`\n→ Pushing ${target.label}...`);
+            try {
+                await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand(target.commandId, argv));
+                this.log(`✓ ${target.label} pushed`);
+                results.push({ label: target.label, status: 'pushed' });
+            }
+            catch (error) {
+                const { message } = error;
+                this.log(`✗ ${target.label} failed: ${message}`);
+                results.push({ error: message, label: target.label, status: 'failed' });
             }
-            throw error;
         }
+        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 push. ${reasons.join('; ')}`);
+        }
+        return { results };
     }
 }
-function isNoop(diff) {
-    return (diff.toInstall.length === 0 && diff.toPin.length === 0 && diff.toRemove.length === 0 && diff.collisions.length === 0);
-}
-function result(diff, status, removed, includeCollisions) {
-    const collisionSlugs = includeCollisions ? diff.collisions.map((c) => c.slug) : [];
-    return {
-        installed: [...diff.toInstall.map((a) => a.slug), ...collisionSlugs],
-        pinned: diff.toPin.map((p) => p.slug),
-        removed,
-        status,
-    };
-}

package/dist/commands/theme/style/diff.d.ts

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

package/dist/commands/{theme-styles → theme/style}/diff.js

@@ -1,5 +1,6 @@
-import { resourceDiffCommand } from '../../lib/diff-command.js';
+import { resourceDiffCommand } from '../../../lib/diff-command.js';
 export default resourceDiffCommand('theme-styles', {
     description: "Show what differs in the active block theme's Global Styles (Site Editor > Styles) between your local file and a WordPress environment, or between two environments",
+    command: 'theme style',
     pathNoun: 'theme styles directory',
 });

package/dist/commands/{theme-styles → theme/style}/pull.d.ts

@@ -1,12 +1,18 @@
-import { LoopressCommand } from '../../lib/base.js';
+import { LoopressCommand } from '../../../lib/base.js';
+type ThemeStylePullResult = {
+    file: 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: {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<ThemeStylePullResult>;
 }
+export {};

package/dist/commands/{theme-styles → theme/style}/pull.js

@@ -1,14 +1,15 @@
 import { Args } from '@oclif/core';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { LoopressCommand } from '../../lib/base.js';
-import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName, } from '../../utils/theme-styles-format.js';
+import { LoopressCommand } from '../../../lib/base.js';
+import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName, } from '../../../utils/theme-styles-format.js';
 export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
     };
     static description = "Pull the active block theme's Global Styles customizations (Site Editor > Styles) from WordPress into a local file";
-    static examples = ['$ lps theme-styles pull'];
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme style pull'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
     };
@@ -22,10 +23,11 @@ export default class Pull extends LoopressCommand {
         const file = join(dir, themeStylesFileName(stylesheet));
         if (this.dryRun) {
             this.log(`[dry-run] Would pull Global Styles for "${stylesheet}" to ${file}`);
-            return;
+            return { file, status: 'dry-run' };
         }
         await mkdir(dir, { recursive: true });
         await writeFile(file, JSON.stringify(canonicalGlobalStyles(item), null, 2) + '\n');
         this.log(`Pulled Global Styles for "${stylesheet}" to ${file}`);
+        return { file, status: 'success' };
     }
 }

package/dist/commands/{theme-styles → theme/style}/push.d.ts

@@ -1,12 +1,19 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { PushCommand } from '../../../lib/push-command.js';
+type ThemeStylePushResult = {
+    file: 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: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<ThemeStylePushResult>;
 }
+export {};

package/dist/commands/{theme-styles → theme/style}/push.js

@@ -1,17 +1,19 @@
 import { Args } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { PushCommand } from '../../lib/push-command.js';
-import { getResourceStateProvider } from '../../lib/resource-state.js';
-import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../utils/theme-styles-format.js';
+import { PushCommand } from '../../../lib/push-command.js';
+import { getResourceStateProvider } from '../../../lib/resource-state.js';
+import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../../utils/theme-styles-format.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
     };
     static description = "Push the local Global Styles file to the active block theme's Site Editor > Styles on WordPress";
-    static examples = ['$ lps theme-styles push'];
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme style push'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Push);
@@ -26,13 +28,13 @@ export default class Push extends PushCommand {
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme-styles pull\` first.`);
+                this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme style pull\` first.`);
             }
             throw error;
         }
         if (this.dryRun) {
             this.log(`[dry-run] Would push: ${file}`);
-            return;
+            return { file, status: 'dry-run' };
         }
         const provider = getResourceStateProvider('theme-styles');
         const beforeState = await this.captureBeforePushState(provider, dir);
@@ -41,5 +43,6 @@ export default class Push extends PushCommand {
         this.log(`Pushed: ${file}`);
         await this.writeAfterPushSnapshot(provider, dir, beforeState);
         await this.recordSuccess();
+        return { file, status: 'success' };
     }
 }

package/dist/commands/theme/style/rollback.d.ts

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

package/dist/commands/theme/style/rollback.js

@@ -0,0 +1,6 @@
+import { resourceRollbackCommand } from '../../../lib/rollback-command.js';
+export default resourceRollbackCommand('theme-styles', {
+    description: "Restore the active theme's Global Styles to a snapshot taken automatically before an earlier `lps theme style push`",
+    command: 'theme style',
+    pathNoun: 'theme styles directory',
+});

package/dist/commands/theme/template/diff.d.ts

@@ -0,0 +1,10 @@
+import { DiffCommand, type DiffJson } from '../../../lib/diff-command.js';
+export default class Diff extends DiffCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<DiffJson>;
+}

package/dist/commands/theme/template/diff.js

@@ -0,0 +1,13 @@
+import { DiffCommand } from '../../../lib/diff-command.js';
+import { getResourceStateProvider } from '../../../lib/resource-state.js';
+export default class Diff extends DiffCommand {
+    static description = 'Show what differs in block templates and parts between your local files and a WordPress environment, or between two environments. Templates and parts edited in the Site Editor show up too.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme template diff', '$ lps theme template diff --env staging', '$ lps theme template diff --env staging --against production'];
+    static flags = { ...DiffCommand.againstFlag };
+    async run() {
+        const { flags } = await this.parse(Diff);
+        const sides = this.resolveSides(flags.against);
+        return this.report(['template', 'part'].map((resource) => this.providerTarget(getResourceStateProvider(resource), sides)), sides);
+    }
+}

package/dist/commands/theme/template/list.d.ts

@@ -0,0 +1,13 @@
+import { LoopressCommand } from '../../../lib/base.js';
+import { type ChildTheme } from '../../../utils/template-format.js';
+type ListResult = Omit<ChildTheme, 'parts' | 'templates'> & {
+    parts: string[];
+    templates: string[];
+};
+export default class List extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<ListResult>;
+}
+export {};

package/dist/commands/theme/template/list.js

@@ -0,0 +1,23 @@
+import { LoopressCommand } from '../../../lib/base.js';
+import { pluralize } from '../../../utils/pluralize.js';
+import { CHILD_THEME_ENDPOINT } from '../../../utils/template-format.js';
+export default class List extends LoopressCommand {
+    static description = 'Show the Loopress child theme of the active block theme: its templates, parts, and those edited in the Site Editor';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme template list'];
+    async run() {
+        const child = await this.wp.get(CHILD_THEME_ENDPOINT);
+        // The markup is only needed by `template diff`, it would drown the JSON output here.
+        const result = { ...child, parts: child.parts.map((part) => part.slug), templates: child.templates.map((template) => template.slug) };
+        if (!child.exists) {
+            this.log(`No Loopress child theme yet (${child.stylesheet}), run lps theme template push.`);
+            return result;
+        }
+        this.log(`${child.stylesheet} (child of ${child.parent}, ${child.active ? 'active' : 'not active'})`);
+        this.log(`  ${pluralize(result.templates.length, 'template')}: ${result.templates.join(', ') || 'none'}`);
+        this.log(`  ${pluralize(result.parts.length, 'part')}: ${result.parts.join(', ') || 'none'}`);
+        if (child.customized.length > 0)
+            this.log(`  Edited in the Site Editor: ${child.customized.join(', ')}`);
+        return result;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { PushCommand } from '../../../lib/push-command.js';
+type PushResult = {
+    active?: boolean;
+    customized?: string[];
+    parts: string[];
+    status: 'dry-run' | 'success';
+    stylesheet?: string;
+    templates: string[];
+};
+export default class Push extends PushCommand {
+    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<PushResult>;
+}
+export {};

package/dist/commands/theme/template/push.js

@@ -0,0 +1,44 @@
+import { PushCommand } from '../../../lib/push-command.js';
+import { getResourceStateProvider } from '../../../lib/resource-state.js';
+import { formatPageProblems } from '../../../utils/page-format.js';
+import { pluralize } from '../../../utils/pluralize.js';
+import { resolveResourceDir } from '../../../utils/resource-dirs.js';
+import { CHILD_THEME_ENDPOINT, readLocalTemplates } from '../../../utils/template-format.js';
+export default class Push extends PushCommand {
+    static description = 'Push block templates (templates/<slug>.html) and template parts (parts/<slug>.html) as the files of a child theme of the active block theme, <parent>-loopress. The child mirrors the project: files removed locally are removed from it. It is never activated for you.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme template push', '$ lps theme template push --dry-run'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        await this.parse(Push);
+        const templatesPath = resolveResourceDir('template', this.localConfig);
+        const partsPath = resolveResourceDir('part', this.localConfig);
+        this.log(`Pushing templates and parts to ${this.siteConfig.url}`);
+        this.log(`Templates path: ${templatesPath}, parts path: ${partsPath}`);
+        const { parts, problems, templates } = await readLocalTemplates(templatesPath, partsPath);
+        if (problems.length > 0) {
+            this.error(`Nothing was pushed, fix these files first:\n  ${formatPageProblems(problems)}`);
+        }
+        const names = { parts: parts.map((part) => part.slug), templates: templates.map((template) => template.slug) };
+        this.log(`Found ${pluralize(templates.length, 'template')} and ${pluralize(parts.length, 'part')}`);
+        if (this.dryRun) {
+            await this.previewRemote(getResourceStateProvider('template'), templatesPath);
+            this.log('[dry-run] Would rewrite the child theme with them.');
+            return { ...names, status: 'dry-run' };
+        }
+        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { parts, templates });
+        await this.recordSuccess();
+        this.log(`Child theme ${child.stylesheet} written.`);
+        if (!child.active) {
+            this.warn(`${child.stylesheet} is not the active theme, so nothing changed on the site yet. Activate it in Appearance > Themes.`);
+        }
+        if (child.customized.length > 0) {
+            this.warn(`Edited in the Site Editor, their database copy still wins over the pushed file: ${child.customized.join(', ')}. ` +
+                'Clear their customizations in Appearance > Editor to use the pushed version.');
+        }
+        return { ...names, active: child.active, customized: child.customized, status: 'success', stylesheet: child.stylesheet };
+    }
+}

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

@@ -0,0 +1,23 @@
+import { LoopressCommand } from '../../../lib/base.js';
+import { type ComposerPullResult } from '../../../utils/composer.js';
+type PullResult = {
+    added: string[];
+    merged: Record<string, string>;
+    skipped?: ComposerPullResult['skipped'];
+    status: '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/version/pull.js

@@ -0,0 +1,43 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../../lib/base.js';
+import { pullIntoComposerJson } from '../../../utils/composer.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 version pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+    };
+    async run() {
+        const { url } = this.siteConfig;
+        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]));
+        // A composer.json is authoritative over loopress.json: pin the live versions there instead.
+        const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
+        if (existsSync(composerJsonPath)) {
+            const result = await pullIntoComposerJson(composerJsonPath, 'theme', incoming, {
+                dryRun: this.dryRun,
+                log: this.log.bind(this),
+            });
+            return { ...result, status: this.dryRun ? 'dry-run' : 'success' };
+        }
+        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/version/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 {};