@loopress/cli 0.28.0 → 0.30.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/pull.d.ts

@@ -1,12 +1,18 @@
 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/style/pull.js

@@ -8,6 +8,7 @@ export default class Pull extends LoopressCommand {
         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 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/style/push.d.ts

@@ -1,12 +1,19 @@
 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/style/push.js

@@ -9,9 +9,11 @@ export default class Push extends PushCommand {
         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 enableJsonFlag = true;
     static examples = ['$ lps theme style push'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Push);
@@ -32,7 +34,7 @@ export default class Push extends PushCommand {
         }
         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/{template → theme/template}/diff.d.ts

@@ -1,4 +1,4 @@
-import { DiffCommand, type DiffJson } from '../../lib/diff-command.js';
+import { DiffCommand, type DiffJson } from '../../../lib/diff-command.js';
 export default class Diff extends DiffCommand {
     static description: string;
     static enableJsonFlag: boolean;

package/dist/commands/{template → theme/template}/diff.js

@@ -1,9 +1,9 @@
-import { DiffCommand } from '../../lib/diff-command.js';
-import { getResourceStateProvider } from '../../lib/resource-state.js';
+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 template diff', '$ lps template diff --env staging', '$ lps template diff --env staging --against production'];
+    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);

package/dist/commands/{template → theme/template}/list.d.ts

@@ -1,5 +1,5 @@
-import { LoopressCommand } from '../../lib/base.js';
-import { type ChildTheme } from '../../utils/template-format.js';
+import { LoopressCommand } from '../../../lib/base.js';
+import { type ChildTheme } from '../../../utils/template-format.js';
 type ListResult = Omit<ChildTheme, 'parts' | 'templates'> & {
     parts: string[];
     templates: string[];

package/dist/commands/{template → theme/template}/list.js

@@ -1,16 +1,16 @@
-import { LoopressCommand } from '../../lib/base.js';
-import { pluralize } from '../../utils/pluralize.js';
-import { CHILD_THEME_ENDPOINT } from '../../utils/template-format.js';
+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 template list'];
+    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 template push.`);
+            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'})`);

package/dist/commands/{template → theme/template}/push.d.ts

@@ -1,11 +1,13 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { PushCommand } from '../../../lib/push-command.js';
 type PushResult = {
     active?: boolean;
+    blockStyles: string[];
     customized?: string[];
     parts: string[];
     status: 'dry-run' | 'success';
     stylesheet?: string;
     templates: string[];
+    unknownBlocks?: string[];
 };
 export default class Push extends PushCommand {
     static description: string;

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

@@ -0,0 +1,65 @@
+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';
+import { bundleThemeCss } from '../../../utils/theme-css.js';
+export default class Push extends PushCommand {
+    static description = 'Push block templates (theme/templates/<slug>.html), template parts (theme/parts/<slug>.html) and the theme CSS (theme/css/style.css, theme/blocks/<namespace>/<block>.css, bundled with esbuild) 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);
+        const { css, problems: cssProblems } = await bundleThemeCss(resolveResourceDir('css', this.localConfig), resolveResourceDir('blockCss', this.localConfig));
+        problems.push(...cssProblems);
+        if (problems.length > 0) {
+            this.error(`Nothing was pushed, fix these files first:\n  ${formatPageProblems(problems)}`);
+        }
+        const names = {
+            blockStyles: css.blocks.map((block) => block.name),
+            parts: parts.map((part) => part.slug),
+            templates: templates.map((template) => template.slug),
+        };
+        this.log(`Found ${pluralize(templates.length, 'template')}, ${pluralize(parts.length, 'part')}, ` +
+            `${css.style ? 'a global stylesheet' : 'no global stylesheet'} and ${pluralize(css.blocks.length, 'block stylesheet')}`);
+        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, { ...css, 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.');
+        }
+        // A warning, never a refusal: the block may come from a plugin active on another environment.
+        const unknownBlocks = child.unknownBlocks ?? [];
+        if (unknownBlocks.length > 0) {
+            this.warn(`No block registered on this site under these names, their CSS will never load: ${unknownBlocks.join(', ')}. ` +
+                'Check the file name in theme/blocks/, or activate the plugin that provides the block.');
+        }
+        return {
+            ...names,
+            active: child.active,
+            customized: child.customized,
+            status: 'success',
+            stylesheet: child.stylesheet,
+            unknownBlocks,
+        };
+    }
+}

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 {};

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

@@ -0,0 +1,123 @@
+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)';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme version push', '$ lps theme version push --force'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+        force: Flags.boolean({ default: false, description: 'Allow downgrades and take over themes installed outside Loopress' }),
+    };
+    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 version 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.');
+            }
+            throw error;
+        }
+    }
+}
+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,
+    };
+}