@loopress/cli 0.29.0 → 0.31.0

package/dist/commands/push.js

@@ -1,47 +1,56 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { LoopressCommand } from '../lib/base.js';
 import { guardProductionPush } from '../lib/guard-production-push.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
+import { PushCommand } from '../lib/push-command.js';
 import { isLocalEnvironment } from '../lib/wp-client.js';
 import { wpackagistRequire } from '../utils/composer.js';
-import { pluralize } from '../utils/pluralize.js';
+import { resolveResourceDir } from '../utils/resource-dirs.js';
 // Dependency-ish order: code first (plugins, composer), then the ACF definitions content
 // relies on, then content itself.
 const PUSH_TARGETS = [
     { commandId: 'plugin:push', label: 'plugins' },
     { commandId: 'composer:push', label: 'composer' },
+    // Before ACF: a field group's location rule can target a Loopress post type or taxonomy.
+    { commandId: 'cpt:push', label: 'post types' },
+    { commandId: 'taxonomy:push', label: 'taxonomies' },
+    { commandId: 'meta:push', label: 'post meta' },
+    { commandId: 'role:push', label: 'roles' },
     { commandId: 'acf:push', label: 'ACF' },
     { commandId: 'api:push', label: 'API routes' },
     { commandId: 'hook:push', label: 'hooks' },
     { commandId: 'form:push', label: 'forms' },
+    // Before templates and pages, which can reference them (`wp:pattern`).
+    { commandId: 'pattern:push', label: 'patterns' },
     // Before pages: WordPress refuses a page whose `template` it doesn't know yet.
     { commandId: 'theme:template:push', label: 'templates and parts' },
     { commandId: 'page:push', label: 'pages' },
-    { commandId: 'seo:push', label: 'SEO' },
     { commandId: 'menu:push', label: 'menus' },
     { 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, hooks, forms, templates, pages, SEO, menus, options, and snippets, to WordPress';
+    static description = 'Push all local content, plugins, composer dependencies, post types, taxonomies, post meta, roles, ACF, API routes, hooks, forms, patterns, templates, pages, menus, options, and snippets, to WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,
+        overwrite: PushCommand.baseFlags.overwrite,
     };
-    failedCount = 0;
     async run() {
         await this.guardProductionPush();
+        this.warnRemovedSeoModule();
         const argv = this.buildArgv();
         const results = [];
-        const composerPushedByPlugins = await this.composerDeclaresPlugins();
+        const skips = await this.skippedTargets();
         for (const target of PUSH_TARGETS) {
-            if (composerPushedByPlugins && target.commandId === 'composer:push') {
-                this.log('\n→ composer: already pushed whole by plugins');
-                results.push({ label: target.label, status: 'pushed' });
+            const skip = skips.get(target.commandId);
+            if (skip) {
+                this.log(`\n→ ${target.label}: ${skip.note}`);
+                results.push({ label: target.label, status: skip.status });
                 continue;
             }
             this.log(`\n→ Pushing ${target.label}...`);
@@ -51,20 +60,16 @@ export default class Push extends LoopressCommand {
                 results.push({ label: target.label, status: 'pushed' });
             }
             catch (error) {
-                this.failedCount++;
                 const { message } = error;
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
+                // Stop here: later targets depend on earlier ones (hooks use what composer installs,
+                // pages need their templates), so pushing them anyway can ship a silently broken site.
+                const skipped = PUSH_TARGETS.slice(PUSH_TARGETS.indexOf(target) + 1).map((next) => next.label);
+                const skippedNote = skipped.length > 0 ? ` Not attempted: ${skipped.join(', ')}.` : '';
+                this.error(`${target.label} failed to push: ${message}.${skippedNote}`);
             }
         }
-        if (this.failedCount > 0) {
-            // Each failure's own reason, not just the count: under --json the per-resource lines above
-            // never reach stdout, and this message is all an MCP caller or a script gets to see.
-            const failures = results
-                .filter((result) => result.status === 'failed')
-                .map((result) => `${result.label}: ${result.error}`);
-            this.error(`${pluralize(this.failedCount, 'resource')} failed to push. ${failures.join('; ')}`);
-        }
         this.log(this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.');
         return { results };
     }
@@ -75,12 +80,15 @@ export default class Push extends LoopressCommand {
         const argv = ['--env', this.siteConfig.name, '--yes'];
         if (this.dryRun)
             argv.push('--dry-run');
+        // Not implied by --yes: overwriting changes made outside Loopress is its own decision.
+        if (this.overwrite)
+            argv.push('--overwrite');
         return argv;
     }
     // A composer.json that declares plugins is pushed whole by `plugin:push` (with its activation
     // safety), so `composer:push` would only run Composer on the server a second time.
     async composerDeclaresPlugins() {
-        const path = join(process.cwd(), this.rootDir, 'composer.json');
+        const path = this.composerJsonPath();
         if (!existsSync(path))
             return false;
         try {
@@ -92,6 +100,9 @@ export default class Push extends LoopressCommand {
             return false;
         }
     }
+    composerJsonPath() {
+        return join(process.cwd(), this.rootDir, 'composer.json');
+    }
     // Guards once here (shared with PushCommand, lib/push-command.ts) rather than once per
     // delegated command.
     async guardProductionPush() {
@@ -102,4 +113,25 @@ export default class Push extends LoopressCommand {
             yes: this.yes,
         });
     }
+    // Unconfigured is not a failure: a project that doesn't manage plugins or composer through
+    // Loopress must not stop the run before anything else gets pushed.
+    async skippedTargets() {
+        const skips = new Map();
+        const notConfigured = { note: 'not configured, skipped', status: 'skipped' };
+        const hasComposerJson = existsSync(this.composerJsonPath());
+        const composerPushedByPlugins = await this.composerDeclaresPlugins();
+        if (composerPushedByPlugins)
+            skips.set('composer:push', { note: 'already pushed whole by plugins', status: 'pushed' });
+        else if (!hasComposerJson)
+            skips.set('composer:push', notConfigured);
+        // With a composer.json, plugins come from it only; otherwise from loopress.json.
+        const pluginsConfigured = hasComposerJson ? composerPushedByPlugins : Object.keys(this.localConfig.plugins ?? {}).length > 0;
+        if (!pluginsConfigured)
+            skips.set('plugin:push', notConfigured);
+        // The only push that fails on a missing directory (the others find 0 files), so a project
+        // that never used snippets would otherwise end every `lps push` on an ENOENT.
+        if (!existsSync(resolve(resolveResourceDir('snippets', this.localConfig))))
+            skips.set('snippet:push', notConfigured);
+        return skips;
+    }
 }

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

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

package/dist/commands/role/diff.js

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

package/dist/commands/role/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredListCommand>;
+export default _default;

package/dist/commands/role/list.js

@@ -0,0 +1,4 @@
+import { declaredListCommand } from '../../lib/declared-type-command.js';
+import { ROLE_SPEC } from '../../utils/declared-type-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default declaredListCommand(ROLE_SPEC, 'List the user roles on WordPress, where each comes from (Loopress, WordPress, a plugin) and how many users have it. Only Loopress ones are pulled and pushed.', (count) => pluralize(count, 'user'));

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/role/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { ROLE_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(ROLE_SPEC, 'Pull the roles Loopress manages on WordPress into roles/<slug>.json files. ' +
+    'Built-in roles and roles created by a plugin are never pulled, see `lps role list`.');

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/role/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { ROLE_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(ROLE_SPEC, 'Push local roles (roles/<slug>.json, a "name" and its "capabilities") to WordPress. ' +
+    'Create or update only, never deletes a role (use `lps role rm`), never changes which users have it.');

package/dist/commands/role/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/role/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { ROLE_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(ROLE_SPEC, 'Stop registering a Loopress role on WordPress. Its users keep it in their profile, with no capability until the role is pushed again.', 'Its users keep it in their profile, with no capability until it is pushed again.');

package/dist/commands/role/rollback.d.ts

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

package/dist/commands/role/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('role', {
+    description: 'Restore roles to a snapshot taken automatically before an earlier `lps role push`',
+    pathNoun: 'roles directory',
+});

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

@@ -24,5 +24,6 @@ export default class Push extends PushCommand {
     private loadSnippets;
     private pushSnippet;
     private toPayload;
+    private withoutDuplicateIds;
 }
 export {};

package/dist/commands/snippet/push.js

@@ -28,7 +28,7 @@ export default class Push extends PushCommand {
         this.log(`Snippets path: ${path}`);
         const provider = getResourceStateProvider('snippet');
         const beforeState = await this.captureBeforePushState(provider, path);
-        const snippets = await this.loadSnippets(path);
+        const snippets = this.withoutDuplicateIds(await this.loadSnippets(path));
         this.log(`Found ${pluralize(snippets.length, 'snippet')} to push`);
         const pushed = [];
         await this.runPushTasks(snippets, (snippet) => snippet.name, async (snippet, task) => {
@@ -148,8 +148,11 @@ export default class Push extends PushCommand {
     toPayload(snippet) {
         return {
             active: snippet.active,
-            code: stripPhpOpeningTag(snippet.code),
-            description: `Imported from ${snippet.path}`,
+            // Only PHP files carry an editor-only `<?php` tag: an HTML snippet starting with an inline
+            // `<?php ... ?>` block is its real content and must reach WordPress untouched.
+            code: snippet.type === 'php' ? stripPhpOpeningTag(snippet.code) : snippet.code,
+            // The sidecar's description wins, so a pull then push never erases one written in wp-admin.
+            description: snippet.description ?? `Imported from ${snippet.path}`,
             insertMethod: snippet.insertMethod,
             location: snippet.location,
             name: snippet.name,
@@ -159,4 +162,22 @@ export default class Push extends PushCommand {
             type: snippet.type,
         };
     }
+    // Two files claiming the same id would each PUT over that id, the last one silently replacing
+    // the other on the site (seen after switching snippet provider, whose ids restart). Neither is
+    // pushed, and the push fails, until the files are fixed by hand.
+    withoutDuplicateIds(snippets) {
+        const pathsById = new Map();
+        for (const { id, path } of snippets) {
+            if (id !== undefined)
+                pathsById.set(id, [...(pathsById.get(id) ?? []), path]);
+        }
+        return snippets.filter((snippet) => {
+            const paths = snippet.id === undefined ? [] : pathsById.get(snippet.id);
+            if (paths.length < 2)
+                return true;
+            this.failedCount++;
+            this.warn(`Skipping "${snippet.path}": id ${snippet.id} is also used by ${paths.filter((p) => p !== snippet.path).join(', ')}.`);
+            return false;
+        });
+    }
 }

package/dist/commands/status.d.ts

@@ -18,8 +18,7 @@ export default class Status extends Command {
         env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<StatusResult>;
-    private reportActiveProject;
-    private reportEnvOverride;
-    private reportPinnedProject;
+    private logTarget;
+    private report;
 }
 export {};

package/dist/commands/status.js

@@ -11,52 +11,26 @@ export default class Status extends Command {
     };
     async run() {
         const { flags } = await this.parse(Status);
-        const localConfig = await readLocalConfig();
-        let info;
-        if (flags.env) {
-            info = this.reportEnvOverride(localConfig.projectId, flags.env);
-        }
-        else if (localConfig.projectId) {
-            info = this.reportPinnedProject(localConfig.projectId);
-        }
-        else {
-            info = this.reportActiveProject();
-        }
+        const { projectId } = await readLocalConfig();
+        const info = this.report(projectId, flags.env);
         this.log('');
         this.log(`Config dir: ${this.config.configDir}`);
         this.log(`Data dir:   ${this.config.dataDir}`);
         return { ...info, configDir: this.config.configDir, dataDir: this.config.dataDir };
     }
-    reportActiveProject() {
-        const env = configManager.getCurrentEnv();
-        const project = env ? configManager.getCurrentProject() : undefined;
-        if (!env || !project) {
-            const note = 'No project configured. Run `lps project config` first.';
-            this.log(note);
-            return { note };
-        }
-        this.log(`Project:  ${project.name} (${env.name})`);
+    logTarget(label, env) {
+        this.log(`Project:  ${label}`);
         this.log(`URL:      ${env.url}`);
-        return { environment: env.name, project: `${project.name} (${env.name})`, url: env.url };
+        return { environment: env.name, project: label, url: env.url };
     }
-    // Mirrors base.ts:resolveEnvironment with --env: the targeted project comes from
-    // loopress.json when pinned, from the globally active project otherwise.
-    reportEnvOverride(pinnedProjectId, envName) {
-        const project = pinnedProjectId ? configManager.getProject(pinnedProjectId) : configManager.getCurrentProject();
-        if (!project) {
+    // Mirrors base.ts:resolveEnvironment, reporting instead of failing where it can.
+    report(pinnedProjectId, envName) {
+        const projectId = pinnedProjectId ?? configManager.getCurrentProject()?.id;
+        if (!projectId) {
             const note = 'No project configured. Run `lps project config` first.';
             this.log(note);
             return { note };
         }
-        const env = project.environments[envName];
-        if (!env) {
-            this.error(`Environment "${envName}" not found in project "${project.name}". Available: ${Object.keys(project.environments).join(', ')}`);
-        }
-        this.log(`Project:  ${project.name} (${env.name}, via --env)`);
-        this.log(`URL:      ${env.url}`);
-        return { environment: env.name, project: `${project.name} (${env.name}, via --env)`, url: env.url };
-    }
-    reportPinnedProject(projectId) {
         const project = configManager.getProject(projectId);
         if (!project) {
             const note = `loopress.json pins project "${projectId}", but it no longer exists. Run \`lps project config\` to configure it.`;
@@ -71,28 +45,22 @@ export default class Status extends Command {
             this.log(note);
             return { note, project: project.name };
         }
-        if (envNames.length === 1) {
-            const env = project.environments[envNames[0]];
-            this.log(`Project:  ${project.name} (${env.name})`);
-            this.log(`URL:      ${env.url}`);
-            return { environment: env.name, project: `${project.name} (${env.name})`, url: env.url };
+        if (envName) {
+            const env = project.environments[envName];
+            if (!env) {
+                this.error(`Environment "${envName}" not found in project "${project.name}". Available: ${envNames.join(', ')}`);
+            }
+            return this.logTarget(`${project.name} (${env.name}, via --env)`, env);
         }
-        const current = configManager.getCurrentProject();
-        const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
-        if (!currentEnv) {
-            const note = `"${project.name}" has multiple environments and isn't the globally active project. Run \`lps project switch\` to pick one.`;
-            this.log(`Project:  ${project.name} ${c('yellow', '(ambiguous)')}`);
+        const env = configManager.getDefaultEnvironment(projectId);
+        if (!env) {
+            const note = `"${project.name}" has no "local" environment, pass --env to pick one.`;
+            this.log(`Project:  ${project.name} ${c('yellow', '(no default environment)')}`);
             this.log(`Environments: ${envNames.join(', ')}`);
             this.log('');
-            this.warn(`"${project.name}" has multiple environments and isn't the globally active project.`);
-            this.log('Run `lps project switch` to pick one before running commands here.');
-            if (current) {
-                this.log(`(Globally active project right now: "${current.name}")`);
-            }
+            this.warn(note);
             return { environments: envNames, note, project: project.name };
         }
-        this.log(`Project:  ${project.name} (${currentEnv.name})`);
-        this.log(`URL:      ${currentEnv.url}`);
-        return { environment: currentEnv.name, project: `${project.name} (${currentEnv.name})`, url: currentEnv.url };
+        return this.logTarget(`${project.name} (${env.name})`, env);
     }
 }

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

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

package/dist/commands/taxonomy/diff.js

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

package/dist/commands/taxonomy/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredListCommand>;
+export default _default;

package/dist/commands/taxonomy/list.js

@@ -0,0 +1,5 @@
+import { declaredListCommand } from '../../lib/declared-type-command.js';
+import { TAXONOMY_SPEC } from '../../utils/declared-type-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+export default declaredListCommand(TAXONOMY_SPEC, 'List the taxonomies registered on WordPress, where each comes from (Loopress, WordPress, ACF, CPT UI, a theme or plugin) ' +
+    'and the post types it attaches to. Only Loopress ones are pulled and pushed.', (count) => pluralize(count, 'term'));

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/taxonomy/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { TAXONOMY_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(TAXONOMY_SPEC, 'Pull the taxonomies Loopress manages on WordPress into taxonomies/<slug>.json files, never their terms. ' +
+    'Taxonomies registered by a theme or another plugin are never pulled, see `lps taxonomy list`.');

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/taxonomy/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { TAXONOMY_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(TAXONOMY_SPEC, 'Push local taxonomies (taxonomies/<slug>.json, register_taxonomy() arguments plus "object_type") to WordPress. ' +
+    'Create or update only, never deletes a taxonomy (use `lps taxonomy rm`), never touches its terms.');

package/dist/commands/taxonomy/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/taxonomy/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { TAXONOMY_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(TAXONOMY_SPEC, 'Stop registering a Loopress taxonomy on WordPress. Its terms are kept in the database, hidden until the taxonomy is pushed again.', "Its terms are kept in the database, hidden until it's pushed again.");

package/dist/commands/taxonomy/rollback.d.ts

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

package/dist/commands/taxonomy/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('taxonomy', {
+    description: 'Restore taxonomies to a snapshot taken automatically before an earlier `lps taxonomy push`',
+    pathNoun: 'taxonomies directory',
+});

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

@@ -1,11 +1,13 @@
 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

@@ -4,8 +4,9 @@ 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 (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 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 = {
@@ -19,17 +20,24 @@ export default class Push extends PushCommand {
         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 = { parts: parts.map((part) => part.slug), templates: templates.map((template) => template.slug) };
-        this.log(`Found ${pluralize(templates.length, 'template')} and ${pluralize(parts.length, 'part')}`);
+        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, { parts, templates });
+        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) {
@@ -39,6 +47,19 @@ export default class Push extends PushCommand {
             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 };
+        // 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.js

@@ -16,8 +16,13 @@ export default class Pull extends LoopressCommand {
         const { url } = this.siteConfig;
         this.log(`Pulling themes from ${url}`);
         const raw = await this.wp.get('wp/v2/themes');
+        // A theme with no Version header can't be pinned, and `theme version push` would then fail on
+        // it: the Loopress child theme (`<parent>-loopress`, written by `theme template push`) is one.
         const installed = parseInstalledThemes(raw);
-        const incoming = Object.fromEntries(installed.map((t) => [t.slug, t.version]));
+        const unversioned = installed.filter((t) => t.version === '').map((t) => t.slug);
+        const incoming = Object.fromEntries(installed.filter((t) => t.version !== '').map((t) => [t.slug, t.version]));
+        if (unversioned.length > 0)
+            this.log(`  - Skipped: ${unversioned.join(', ')} (no version to pin)`);
         // 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)) {

package/dist/config/project-config.manager.d.ts

@@ -8,15 +8,15 @@ export declare class ProjectConfigManager {
         id: string;
     });
     getConfigFilePath(): string;
-    getCurrentEnv(): EnvironmentConfig | null;
     getCurrentProject(): null | (ProjectConfig & {
         id: string;
     });
+    getDefaultEnvironment(projectId: string): EnvironmentConfig | null;
     getEnvironment(projectId: string, envName: string): EnvironmentConfig | null;
     getProject(id: string): null | ProjectConfig;
     isTelemetryDisabled(): boolean;
     listEnvironments(projectId: string): Array<EnvironmentConfig & {
-        isCurrent: boolean;
+        isDefault: boolean;
     }>;
     listProjects(): Array<ProjectConfig & {
         id: string;
@@ -26,7 +26,7 @@ export declare class ProjectConfigManager {
     removeEnvironment(projectId: string, envName: string): void;
     removeProject(id: string): void;
     setConfigDir(configDir: string): void;
-    setCurrent(projectId: string, envName: string): void;
+    setCurrent(projectId: string): void;
     setEnvironment(projectId: string, envName: string, env: EnvironmentConfig): void;
     setEnvironmentApiId(projectId: string, envName: string, apiEnvironmentId: string): void;
     setProject(id: string, project: ProjectConfig): void;