@loopress/cli 0.32.2 → 0.33.0

package/dist/commands/push.js

@@ -2,17 +2,22 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../lib/base.js';
+import { integrationFix, missingIntegration, missingModule } from '../lib/capabilities.js';
 import { guardProductionPush } from '../lib/guard-production-push.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
+import { errorMessage } from '../lib/narrow.js';
 import { PushCommand } from '../lib/push-command.js';
 import { isLocalEnvironment } from '../lib/wp-client.js';
-import { wpackagistRequire } from '../utils/composer.js';
-import { projectUses, resolveResourceDir } from '../utils/resource-dirs.js';
+import { parseComposerJson, wpackagistRequire } from '../utils/composer.js';
+import { projectHasChildThemeFiles, projectUses, resolveResourceDir } from '../utils/resource-dirs.js';
 import { globalStylesSkipNote } from '../utils/theme-styles-format.js';
 // Backed by a plugin the site may not have (ACF, a form or a snippet plugin): a project without
 // the resource's directory doesn't use it, and its push, dry run included, would only stop on the
 // site's 409 or the missing directory.
 const PLUGIN_BACKED = { 'acf:push': 'acf', 'form:push': 'form', 'snippet:push': 'snippets' };
+// Features of Loopress Full only: on Light, skipped while the project doesn't use them, refused
+// upfront when it does. On Full they run as usual, used or not.
+const FULL_ONLY = { 'api:push': 'api', 'block:push': 'block', 'hook:push': 'hooks', 'page:push': 'page', 'pattern:push': 'pattern' };
 // Dependency-ish order: code first (plugins, composer), then the ACF definitions content
 // relies on, then content itself.
 const PUSH_TARGETS = [
@@ -26,6 +31,8 @@ const PUSH_TARGETS = [
     { commandId: 'acf:push', label: 'ACF' },
     { commandId: 'api:push', label: 'API routes' },
     { commandId: 'hook:push', label: 'hooks' },
+    // Before templates and pages, which place them (`wp:loopress/<slug>`).
+    { commandId: 'block:push', label: 'dynamic blocks' },
     { commandId: 'form:push', label: 'forms' },
     // Before templates and pages, which can reference them (`wp:pattern`).
     { commandId: 'pattern:push', label: 'patterns' },
@@ -40,7 +47,7 @@ const PUSH_TARGETS = [
     { commandId: 'snippet:push', label: 'snippets' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push every local resource to WordPress in one run: plugins, composer dependencies, post types, taxonomies, post meta, roles, ACF, API routes, hooks, forms, patterns, templates and parts, Global Styles, pages, menus, options, and snippets';
+    static description = 'Push every local resource to WordPress in one run: plugins, composer dependencies, post types, taxonomies, post meta, roles, ACF, API routes, hooks, dynamic blocks, forms, patterns, templates and parts, Global Styles, pages, menus, options, and snippets';
     static enableJsonFlag = true;
     static examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run'];
     static flags = {
@@ -50,7 +57,6 @@ export default class Push extends LoopressCommand {
     };
     async run() {
         await this.guardProductionPush();
-        this.warnRemovedSeoModule();
         const argv = this.buildArgv();
         const results = [];
         const skips = await this.skippedTargets();
@@ -68,7 +74,7 @@ export default class Push extends LoopressCommand {
                 results.push({ label: target.label, result, status: 'pushed' });
             }
             catch (error) {
-                const { message } = error;
+                const message = errorMessage(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,
@@ -81,6 +87,28 @@ export default class Push extends LoopressCommand {
         this.log(this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.');
         return { results };
     }
+    // A step the project uses on a site that can't hold it would only fail at its turn, after
+    // everything before it was pushed: refuse the whole run upfront, saying how to fix it. An unused
+    // one is skipped, saying why when the site lacks it.
+    applySiteSteps(steps, skips, declared) {
+        const blockers = [];
+        for (const { commandId, missing, skipUnused, used } of steps) {
+            if (used && missing) {
+                const label = PUSH_TARGETS.find((target) => target.commandId === commandId)?.label;
+                const fix = integrationFix(missing, declared);
+                const fixSentence = fix ? ` ${fix}.` : '';
+                blockers.push(`${label}: ${missing.reason} on ${this.siteConfig.name}.${fixSentence}`);
+            }
+            else if (!used && missing?.needsFull) {
+                skips.set(commandId, { note: `${missing.reason}, skipped`, status: 'skipped' });
+            }
+            else if (!used && skipUnused) {
+                skips.set(commandId, { note: 'not configured, skipped', status: 'skipped' });
+            }
+        }
+        if (blockers.length > 0)
+            this.error(`Nothing was pushed, the project uses what this site can't hold:\n  ${blockers.join('\n  ')}`);
+    }
     // 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 delegated command would re-run its own production guard.
@@ -93,24 +121,22 @@ export default class Push extends LoopressCommand {
             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 = this.composerJsonPath();
-        if (!existsSync(path))
-            return false;
+    composerJsonPath() {
+        return join(process.cwd(), this.rootDir, 'composer.json');
+    }
+    // The wordpress.org plugins the project declares: composer.json's wpackagist plugins when it
+    // exists, loopress.json's otherwise. Unreadable or invalid composer.json: none, the commands report it.
+    async declaredPlugins(hasComposerJson) {
+        if (!hasComposerJson)
+            return Object.keys(this.localConfig.plugins ?? {});
         try {
-            const composerJson = JSON.parse(await readFile(path, 'utf8'));
-            return Object.keys(wpackagistRequire(composerJson, 'plugin', isLocalEnvironment(this.siteConfig.name))).length > 0;
+            const composerJson = parseComposerJson(await readFile(this.composerJsonPath(), 'utf8'));
+            return Object.keys(wpackagistRequire(composerJson, 'plugin', isLocalEnvironment(this.siteConfig.name)));
         }
         catch {
-            // Unreadable: let both commands run and report the parse error themselves.
-            return false;
+            return [];
         }
     }
-    composerJsonPath() {
-        return join(process.cwd(), this.rootDir, 'composer.json');
-    }
     // The site unreachable or the theme list refused: let the step run and report it itself.
     async globalStylesSkipNote() {
         try {
@@ -136,19 +162,37 @@ export default class Push extends LoopressCommand {
         const skips = new Map();
         const notConfigured = { note: 'not configured, skipped', status: 'skipped' };
         const hasComposerJson = existsSync(this.composerJsonPath());
-        const composerPushedByPlugins = await this.composerDeclaresPlugins();
+        const declaredPlugins = await this.declaredPlugins(hasComposerJson);
+        // 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.
+        const composerPushedByPlugins = hasComposerJson && declaredPlugins.length > 0;
         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)
+        if (declaredPlugins.length === 0)
             skips.set('plugin:push', notConfigured);
-        for (const [commandId, kind] of Object.entries(PLUGIN_BACKED)) {
-            if (!projectUses(kind, this.localConfig))
-                skips.set(commandId, notConfigured);
-        }
+        const capabilities = await this.capabilities();
+        const missingDependencies = missingModule('dependencies', 'plugins and Composer', capabilities);
+        const steps = [
+            ...['plugin:push', 'composer:push'].map((commandId) => ({ commandId, missing: missingDependencies, skipUnused: false, used: !skips.has(commandId) })),
+            ...Object.entries(PLUGIN_BACKED).map(([commandId, kind]) => ({
+                commandId,
+                missing: missingIntegration(kind, capabilities),
+                skipUnused: true,
+                used: projectUses(kind, this.localConfig),
+            })),
+            ...Object.entries(FULL_ONLY).map(([commandId, kind]) => ({
+                commandId,
+                missing: missingIntegration(kind, capabilities),
+                skipUnused: false,
+                used: projectUses(kind, this.localConfig),
+            })),
+            // Without templates, parts or CSS, the step would only write an empty child theme.
+            { commandId: 'theme:template:push', missing: missingIntegration('template', capabilities), skipUnused: true, used: projectHasChildThemeFiles(this.localConfig) },
+        ];
+        this.applySiteSteps(steps, skips, { fromComposer: hasComposerJson, plugins: declaredPlugins });
         const stylesNote = await this.globalStylesSkipNote();
         if (stylesNote)
             skips.set('theme:style:push', { note: stylesNote, status: 'skipped' });

package/dist/commands/snippet/publish.js

@@ -1,9 +1,11 @@
 import { Args, Command } from '@oclif/core';
-import { join } from 'node:path';
 import { ApiClient } from '../../lib/api-client.js';
 import { loadSnippets } from '../../lib/load-snippets.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { resolveLinkedProject } from '../../lib/resolve-linked-project.js';
+import {} from '../../types/snippet.js';
 import { pluralize } from '../../utils/pluralize.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
 import { toSlug } from '../../utils/to-slug.js';
 // Publishes to the Loopress api (not a WordPress site), so this does not extend
 // `LoopressCommand`/`PushCommand`: those force an environment to be resolved, but a project
@@ -18,14 +20,16 @@ export default class Publish extends Command {
     async run() {
         const { args } = await this.parse(Publish);
         const { apiProjectId, localConfig, token } = await resolveLinkedProject((message) => this.error(message));
-        const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.snippetsDir ?? 'snippets');
+        const path = resolveResourceDir('snippets', localConfig, args.path);
         this.log(`Publishing snippets from ${path}`);
         let snippets;
         try {
-            snippets = await loadSnippets(path);
+            snippets = await loadSnippets(path, (message) => {
+                this.warn(message);
+            });
         }
         catch (error) {
-            this.error(error.message);
+            this.error(errorMessage(error));
         }
         const api = new ApiClient(token);
         try {
@@ -34,7 +38,7 @@ export default class Publish extends Command {
             });
         }
         catch (error) {
-            this.error(error.message);
+            this.error(errorMessage(error));
         }
         this.log(`Published ${pluralize(snippets.length, 'snippet')} to your Loopress account.`);
     }

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

@@ -1,6 +1,6 @@
 import { type PushChange, PushCommand } from '../../lib/push-command.js';
 type PushedSnippet = {
-    id?: number;
+    id?: number | undefined;
     name: string;
 };
 type PushResult = {

package/dist/commands/snippet/push.js

@@ -2,10 +2,13 @@ import { Args } from '@oclif/core';
 import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
+import { errorCode, errorMessage, isRecord } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
+import {} from '../../types/snippet.generated.js';
+import {} from '../../types/snippet.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 import { toSlug } from '../../utils/to-slug.js';
@@ -65,18 +68,18 @@ export default class Push extends PushCommand {
         const currentBase = basename(snippet.path, ext);
         const canonicalBase = `${id}-${toSlug(name)}`;
         const oldMetaPath = join(dir, `${currentBase}.json`);
-        let meta = {};
+        let existing = {};
         try {
-            const existing = await readFile(oldMetaPath, 'utf8');
-            meta = JSON.parse(existing);
+            const parsed = JSON.parse(await readFile(oldMetaPath, 'utf8'));
+            if (isRecord(parsed))
+                existing = parsed;
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
+            if (errorCode(error) !== 'ENOENT')
                 throw error;
         }
-        meta.id = id;
-        meta.name = name;
-        meta.type = snippet.type;
+        // Spread, not rebuilt: keys the CLI doesn't know about survive, in their original order.
+        const meta = { ...existing, id, name, type: snippet.type };
         // Persist the id against the *current* file pairing before renaming anything, so a
         // crash between the rename and the sidecar write still leaves a valid `<name>.<ext>` /
         // `<name>.json` pair with the id on disk, and a retried `snippet push` won't re-create
@@ -95,7 +98,7 @@ export default class Push extends PushCommand {
             return await loadSnippetsFromDisk(path, (message) => { this.warn(message); });
         }
         catch (error) {
-            this.error(error.message);
+            this.error(errorMessage(error));
         }
     }
     async pushSnippet(snippet, task) {
@@ -134,15 +137,15 @@ export default class Push extends PushCommand {
                 id = createdSnippet.id;
                 await this.ensureCanonicalFilename(snippet, createdSnippet.id, createdSnippet.name);
             }
-            else {
-                await this.ensureCanonicalFilename(snippet, snippet.id, snippet.name);
+            else if (id !== undefined) {
+                await this.ensureCanonicalFilename(snippet, id, snippet.name);
             }
             if (task)
                 task.output = `Pushed: ${snippet.name}`;
             return id;
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${snippet.name}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${snippet.name}: ${errorMessage(error)}`, error, task);
         }
     }
     toPayload(snippet) {
@@ -172,7 +175,7 @@ export default class Push extends PushCommand {
                 pathsById.set(id, [...(pathsById.get(id) ?? []), path]);
         }
         return snippets.filter((snippet) => {
-            const paths = snippet.id === undefined ? [] : pathsById.get(snippet.id);
+            const paths = snippet.id === undefined ? [] : (pathsById.get(snippet.id) ?? []);
             if (paths.length < 2)
                 return true;
             this.failedCount++;

package/dist/commands/status.js

@@ -1,5 +1,6 @@
 import { Command, Flags, ux } from '@oclif/core';
 import { configManager } from '../config/project-config.manager.js';
+import {} from '../types/config.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 const c = ux.colorize;
 export default class Status extends Command {

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

@@ -0,0 +1,21 @@
+import { LoopressCommand } from '../../lib/base.js';
+type ActivateResult = {
+    active: string;
+    previous: string;
+    status: 'activated' | 'dry-run' | 'unchanged';
+};
+export default class Activate extends LoopressCommand {
+    static args: {
+        stylesheet: 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<ActivateResult>;
+    private childStylesheet;
+}
+export {};

package/dist/commands/theme/activate.js

@@ -0,0 +1,44 @@
+import { Args } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { activateTheme } from '../../lib/capabilities.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+export default class Activate extends LoopressCommand {
+    static args = {
+        stylesheet: Args.string({ description: 'Theme to activate (default: the Loopress child theme, <parent>-loopress)' }),
+    };
+    static description = 'Activate a theme on WordPress, the Loopress child theme by default. A child theme without settings of its own starts from a copy of its parent\'s theme mods and Global Styles. Set "activateChildTheme": true in loopress.json to have `lps theme template push` keep the child active.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme activate', '$ lps theme activate twentytwentyfive --env staging', '$ lps theme activate --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Activate);
+        const { theme } = await this.capabilities();
+        const stylesheet = args.stylesheet ?? this.childStylesheet(theme);
+        if (stylesheet === theme.active) {
+            this.log(`${stylesheet} is already the active theme.`);
+            return { active: stylesheet, previous: theme.active, status: 'unchanged' };
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would activate ${stylesheet} instead of ${theme.active}.`);
+            return { active: stylesheet, previous: theme.active, status: 'dry-run' };
+        }
+        await guardProductionPush({ dryRun: this.dryRun, error: (message) => this.error(message), siteConfig: this.siteConfig, yes: this.yes });
+        const activation = await activateTheme(this.wp, stylesheet);
+        this.log(`Activated ${activation.active} (was ${activation.previous}).`);
+        return { active: activation.active, previous: activation.previous, status: 'activated' };
+    }
+    childStylesheet(theme) {
+        if (theme.child === undefined) {
+            this.error('The Loopress child theme needs Loopress Full. Name the theme to activate instead.');
+        }
+        else if (theme.child === null) {
+            this.error(`The active theme "${theme.active}" can't have a Loopress child theme: it needs a block theme that isn't already a child theme.`);
+        }
+        if (!theme.child.exists)
+            this.error(`${theme.child.stylesheet} doesn't exist yet. Run \`lps theme template push\` first.`);
+        return theme.child.stylesheet;
+    }
+}

package/dist/commands/theme/pull.js

@@ -1,5 +1,6 @@
 import { LoopressCommand } from '../../lib/base.js';
 import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { pluralize } from '../../utils/pluralize.js';
 // Templates and parts have no pull: the child theme is written from the project, never read back.
 const PULL_TARGETS = [
@@ -26,7 +27,7 @@ export default class Pull extends LoopressCommand {
                 results.push({ label: target.label, status: 'pulled' });
             }
             catch (error) {
-                const { message } = error;
+                const message = errorMessage(error);
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
             }

package/dist/commands/theme/push.js

@@ -4,7 +4,9 @@ import { join } 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 { errorMessage } from '../../lib/narrow.js';
 import { pluralize } from '../../utils/pluralize.js';
+import { projectHasChildThemeFiles } from '../../utils/resource-dirs.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 = [
@@ -13,7 +15,7 @@ const PUSH_TARGETS = [
     { commandId: 'theme:style:push', label: 'Global Styles' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push everything theme related to WordPress: theme versions from loopress.json, then block templates and parts, then Global Styles. Never switches the active theme.';
+    static description = 'Push everything theme related to WordPress: theme versions from loopress.json, then block templates and parts, then Global Styles. Switches the active theme only to the Loopress child, when loopress.json sets "activateChildTheme": true.';
     static enableJsonFlag = true;
     static examples = ['$ lps theme push', '$ lps theme push --env staging', '$ lps theme push --dry-run'];
     static flags = {
@@ -34,7 +36,9 @@ export default class Push extends LoopressCommand {
         // 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');
+        // Same for templates: without templates, parts or CSS the step would refuse (nothing to push).
+        const hasChildTheme = projectHasChildThemeFiles(this.localConfig);
+        const targets = PUSH_TARGETS.filter((target) => (hasVersions || target.commandId !== 'theme:version:push') && (hasChildTheme || target.commandId !== 'theme:template:push'));
         const results = [];
         for (const target of targets) {
             const argv = ['--env', this.siteConfig.name, '--production-confirmed'];
@@ -51,7 +55,7 @@ export default class Push extends LoopressCommand {
                 results.push({ label: target.label, result, status: 'pushed' });
             }
             catch (error) {
-                const { message } = error;
+                const message = errorMessage(error);
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
             }

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

@@ -1,6 +1,7 @@
 import { Args } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { errorCode, isRecord } from '../../../lib/narrow.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';
@@ -27,7 +28,7 @@ export default class Push extends PushCommand {
             raw = await readFile(file, 'utf8');
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
+            if (errorCode(error) === 'ENOENT') {
                 this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme style pull\` first.`);
             }
             throw error;
@@ -38,7 +39,11 @@ export default class Push extends PushCommand {
         if (this.dryRun)
             return { changes: this.previewChanges, file, status: 'dry-run' };
         const local = JSON.parse(raw);
-        await this.wp.post(globalStylesEndpoint(id), { settings: local.settings ?? {}, styles: local.styles ?? {} });
+        // Never fall back to empty settings/styles: that push would wipe the site's customizations.
+        if (!isRecord(local))
+            throw new Error(`${file} is not a JSON object`);
+        const { settings, styles } = local;
+        await this.wp.post(globalStylesEndpoint(id), { settings: settings ?? {}, styles: styles ?? {} });
         this.log(`Pushed: ${file}`);
         await this.writeAfterPushSnapshot(provider, dir, beforeState);
         await this.recordSuccess();

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

@@ -1,12 +1,15 @@
 import { createHash } from 'node:crypto';
+import { activateTheme } from '../../../lib/capabilities.js';
+import {} from '../../../lib/diff-state.js';
+import { errorMessage } from '../../../lib/narrow.js';
 import { logChanges, pushChanges, PushCommand } from '../../../lib/push-command.js';
 import { formatPageProblems } from '../../../utils/page-format.js';
 import { pluralize } from '../../../utils/pluralize.js';
-import { resolveResourceDir } from '../../../utils/resource-dirs.js';
+import { projectHasChildThemeFiles, 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 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 activated only when loopress.json sets "activateChildTheme": true, see `lps theme activate`.';
     static enableJsonFlag = true;
     static examples = ['$ lps theme template push', '$ lps theme template push --dry-run'];
     static flags = {
@@ -17,6 +20,10 @@ export default class Push extends PushCommand {
         await this.parse(Push);
         const templatesPath = resolveResourceDir('template', this.localConfig);
         const partsPath = resolveResourceDir('part', this.localConfig);
+        // Pushing would only create an empty child theme as a side effect.
+        if (!projectHasChildThemeFiles(this.localConfig)) {
+            this.error(`Nothing to push: no ${templatesPath}, ${partsPath}, ${resolveResourceDir('css', this.localConfig)} or ${resolveResourceDir('blockCss', this.localConfig)} directory.`);
+        }
         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);
@@ -37,13 +44,25 @@ export default class Push extends PushCommand {
             logChanges((message) => { this.log(message); }, changes.templates, 'templates/');
             logChanges((message) => { this.log(message); }, changes.parts, 'parts/');
             logChanges((message) => { this.log(message); }, changes.css, 'css/');
+            if (this.localConfig.activateChildTheme) {
+                const { child } = (await this.capabilities()).theme;
+                if (child && !child.active)
+                    this.log(`[dry-run] Would activate ${child.stylesheet}.`);
+            }
             return { ...names, changes, 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.`);
+        // Activated only when the project asks for it: a theme switch changes every per-theme setting.
+        let { active } = child;
+        if (!active && this.localConfig.activateChildTheme) {
+            const activation = await activateTheme(this.wp, child.stylesheet);
+            active = true;
+            this.log(`Activated ${child.stylesheet} (was ${activation.previous}), as loopress.json's activateChildTheme asks.`);
+        }
+        if (!active) {
+            this.warn(`${child.stylesheet} is not the active theme, so nothing changed on the site yet. Run \`lps theme activate\`, or set "activateChildTheme": true in loopress.json.`);
         }
         if (child.customized.length > 0) {
             this.warn(`Edited in the Site Editor, their database copy still wins over the pushed file: ${child.customized.join(', ')}. ` +
@@ -57,7 +76,7 @@ export default class Push extends PushCommand {
         }
         return {
             ...names,
-            active: child.active,
+            active,
             customized: child.customized,
             status: 'success',
             stylesheet: child.stylesheet,
@@ -71,7 +90,7 @@ export default class Push extends PushCommand {
             child = await this.wp.get(CHILD_THEME_ENDPOINT);
         }
         catch (error) {
-            this.error(`The site would refuse this push: ${error.message}`);
+            this.error(`The site would refuse this push: ${errorMessage(error)}`);
         }
         const localCss = new Map(css.blocks.map((block) => [`blocks/${block.name}.css`, sha256(block.css)]));
         if (css.style !== '')

package/dist/config/auth.manager.d.ts

@@ -1,11 +1,13 @@
-export type ConsoleAuth = {
-    email?: string;
-    savedAt: string;
-    token: string;
-};
+import { z } from 'zod';
+declare const CONSOLE_AUTH: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    savedAt: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type ConsoleAuth = z.infer<typeof CONSOLE_AUTH>;
 export declare class AuthManager {
-    private dataDir?;
-    constructor(dataDir?: string | undefined);
+    private dataDir;
+    constructor(dataDir?: string);
     clearAuth(): void;
     getAuth(): ConsoleAuth | null;
     getAuthFilePath(): string;
@@ -14,3 +16,4 @@ export declare class AuthManager {
     private requireDataDir;
 }
 export declare const authManager: AuthManager;
+export {};

package/dist/config/auth.manager.js

@@ -1,6 +1,8 @@
 import { existsSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import { z } from 'zod';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
+const CONSOLE_AUTH = z.object({ email: z.string().optional(), savedAt: z.string(), token: z.string() });
 export class AuthManager {
     dataDir;
     constructor(dataDir) {
@@ -12,7 +14,9 @@ export class AuthManager {
             unlinkSync(filePath);
     }
     getAuth() {
-        return readJsonFile(this.getAuthFilePath());
+        // A hand-edited or truncated auth.json reads as logged out, not as a token-less session.
+        const result = CONSOLE_AUTH.safeParse(readJsonFile(this.getAuthFilePath()));
+        return result.success ? result.data : null;
     }
     getAuthFilePath() {
         return join(this.requireDataDir(), 'auth.json');

package/dist/config/json-file.d.ts

@@ -1,2 +1,2 @@
-export declare function readJsonFile<T>(filePath: string): null | T;
+export declare function readJsonFile(filePath: string): unknown;
 export declare function writeJsonFileAtomic(filePath: string, data: unknown): void;

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

@@ -1,7 +1,7 @@
 import { type EnvironmentConfig, type LoopressConfig, type ProjectConfig } from '../types/config.js';
 export declare class ProjectConfigManager {
-    private configDir?;
-    constructor(configDir?: string | undefined);
+    private configDir;
+    constructor(configDir?: string);
     createProjectId(name: string): string;
     ensureConfigDir(): void;
     findProjectByApiId(apiProjectId: string): null | (ProjectConfig & {