@loopress/cli 0.33.0 → 0.35.0

package/dist/commands/push.js

@@ -6,8 +6,10 @@ import { integrationFix, missingIntegration, missingModule } from '../lib/capabi
 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 { postDeployment, PushCommand, startDeploymentCollector, stopDeploymentCollector } from '../lib/push-command.js';
+import { parseSelectionFlag, selectionFlags, selectResources } from '../lib/resource-selection.js';
 import { isLocalEnvironment } from '../lib/wp-client.js';
+import { pinActive } from '../types/plugin.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';
@@ -16,55 +18,77 @@ import { globalStylesSkipNote } from '../utils/theme-styles-format.js';
 // 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.
+// upfront when it does. Like every other resource, skipped when the project doesn't use them.
 const FULL_ONLY = { 'api:push': 'api', 'block:push': 'block', 'hook:push': 'hooks', 'page:push': 'page', 'pattern:push': 'pattern' };
+// Always available on the site: nothing to refuse, but a project without the resource's
+// directory has nothing to push, so the step is skipped instead of running on an empty directory.
+const CORE_BACKED = { 'cpt:push': 'cpt', 'menu:push': 'menu', 'meta:push': 'meta', 'option:push': 'options', 'role:push': 'role', 'taxonomy:push': 'taxonomy' };
 // 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' },
+    { commandId: 'plugin:push', id: 'plugin', label: 'plugins' },
+    { commandId: 'composer:push', id: 'composer', 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: 'cpt:push', id: 'cpt', label: 'post types' },
+    { commandId: 'taxonomy:push', id: 'taxonomy', label: 'taxonomies' },
+    { commandId: 'meta:push', id: 'meta', label: 'post meta' },
+    { commandId: 'role:push', id: 'role', label: 'roles' },
+    { commandId: 'acf:push', id: 'acf', label: 'ACF' },
+    { commandId: 'api:push', id: 'api', label: 'API routes' },
+    { commandId: 'hook:push', id: 'hook', label: 'hooks' },
     // Before templates and pages, which place them (`wp:loopress/<slug>`).
-    { commandId: 'block:push', label: 'dynamic blocks' },
-    { commandId: 'form:push', label: 'forms' },
+    { commandId: 'block:push', id: 'block', label: 'dynamic blocks' },
+    { commandId: 'form:push', id: 'form', label: 'forms' },
     // Before templates and pages, which can reference them (`wp:pattern`).
-    { commandId: 'pattern:push', label: 'patterns' },
+    { commandId: 'pattern:push', id: 'pattern', label: 'patterns' },
     // Before pages: WordPress refuses a page whose `template` it doesn't know yet.
-    { commandId: 'theme:template:push', label: 'templates and parts' },
+    { commandId: 'theme:template:push', id: 'template', label: 'templates and parts' },
     // Belong to whichever theme is active, so right after its templates. Theme versions stay out:
     // installing or removing themes is `lps theme push`'s call.
-    { commandId: 'theme:style:push', label: 'Global Styles' },
-    { commandId: 'page:push', label: 'pages' },
-    { commandId: 'menu:push', label: 'menus' },
-    { commandId: 'option:push', label: 'options' },
-    { commandId: 'snippet:push', label: 'snippets' },
+    { commandId: 'theme:style:push', id: 'theme-style', label: 'Global Styles' },
+    { commandId: 'page:push', id: 'page', label: 'pages' },
+    { commandId: 'menu:push', id: 'menu', label: 'menus' },
+    { commandId: 'option:push', id: 'option', label: 'options' },
+    { commandId: 'snippet:push', id: 'snippet', label: 'snippets' },
 ];
+const PUSH_IDS = PUSH_TARGETS.map((target) => target.id);
 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, 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 examples = ['$ lps push', '$ lps push --env staging', '$ lps push --dry-run', '$ lps push --only acf,page', '$ lps push --skip plugin --skip composer'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,
+        ...selectionFlags('push', PUSH_IDS),
+        ...LoopressCommand.skipUnsupportedFlag,
         overwrite: PushCommand.baseFlags.overwrite,
     };
+    skipUnsupported = false;
+    // What --skip-unsupported held back, for the final warning.
+    unsupported = [];
     async run() {
         await this.guardProductionPush();
+        const { flags } = await this.parse(Push);
+        this.skipUnsupported = flags['skip-unsupported'];
+        const skipFlag = parseSelectionFlag(flags.skip, 'skip', PUSH_IDS, (message) => this.error(message));
+        const selected = new Set(selectResources(PUSH_IDS, parseSelectionFlag(flags.only, 'only', PUSH_IDS, (message) => this.error(message)), skipFlag));
         const argv = this.buildArgv();
         const results = [];
-        const skips = await this.skippedTargets();
+        const skips = await this.skippedTargets(selected, skipFlag.includes('composer'));
+        // The steps run in process and would each post their own record: collect, and post once.
+        const collected = startDeploymentCollector();
+        const record = async (status) => {
+            stopDeploymentCollector();
+            if (this.dryRun)
+                return;
+            const steps = results.map((result, index) => ({ command: PUSH_TARGETS[index]?.commandId ?? '', status: result.status }));
+            await postDeployment({ command: 'push', status, steps, url: this.siteConfig.url, ...(collected.plugins && { plugins: collected.plugins }) });
+        };
         for (const target of PUSH_TARGETS) {
             const skip = skips.get(target.commandId);
             if (skip) {
                 this.log(`\n→ ${target.label}: ${skip.note}`);
-                results.push({ label: target.label, status: skip.status });
+                results.push({ label: target.label, ...(skip.reason && { reason: skip.reason }), status: skip.status });
                 continue;
             }
             this.log(`\n→ Pushing ${target.label}...`);
@@ -79,12 +103,18 @@ export default class Push extends LoopressCommand {
                 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 skipped = PUSH_TARGETS.slice(PUSH_TARGETS.indexOf(target) + 1)
+                    .filter((next) => !skips.has(next.commandId))
+                    .map((next) => next.label);
                 const skippedNote = skipped.length > 0 ? ` Not attempted: ${skipped.join(', ')}.` : '';
+                this.warnUnsupported();
+                await record('failure');
                 this.error(`${target.label} failed to push: ${message}.${skippedNote}`);
             }
         }
-        this.log(this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.');
+        await record('success');
+        this.log(this.doneMessage(selected.size < PUSH_IDS.length));
+        this.warnUnsupported();
         return { results };
     }
     // A step the project uses on a site that can't hold it would only fail at its turn, after
@@ -94,10 +124,13 @@ export default class Push extends LoopressCommand {
         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}`);
+                const line = this.unsupportedLine(commandId, missing, declared);
+                if (this.skipUnsupported) {
+                    skips.set(commandId, { note: `${missing.reason}, skipped (--skip-unsupported)`, reason: `${missing.reason} on ${this.siteConfig.name}`, status: 'skipped' });
+                    this.unsupported.push(line);
+                }
+                else
+                    blockers.push(line);
             }
             else if (!used && missing?.needsFull) {
                 skips.set(commandId, { note: `${missing.reason}, skipped`, status: 'skipped' });
@@ -137,6 +170,13 @@ export default class Push extends LoopressCommand {
             return [];
         }
     }
+    // A run narrowed by --only / --skip must not read as a full push. Unused resources skipped
+    // on a plain run don't count: that run still pushes everything the project has.
+    doneMessage(narrowed) {
+        if (narrowed)
+            return this.dryRun ? '\nEvery selected resource would push, the others are skipped.' : '\nSelected resources pushed, the others are skipped.';
+        return this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.';
+    }
     // The site unreachable or the theme list refused: let the step run and report it itself.
     async globalStylesSkipNote() {
         try {
@@ -158,14 +198,20 @@ export default class Push extends LoopressCommand {
     }
     // 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() {
+    // `composerSkipped`: `composer` was named in --skip, as opposed to just left out of --only.
+    async skippedTargets(selected, composerSkipped) {
         const skips = new Map();
+        const isSelected = (commandId) => selected.has(PUSH_TARGETS.find((target) => target.commandId === commandId)?.id ?? '');
         const notConfigured = { note: 'not configured, skipped', status: 'skipped' };
         const hasComposerJson = existsSync(this.composerJsonPath());
         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;
+        const composerPushedByPlugins = hasComposerJson && declaredPlugins.length > 0 && isSelected('plugin:push');
+        // That push runs Composer on the server, so a run told to skip Composer can't push plugins.
+        if (composerPushedByPlugins && composerSkipped) {
+            this.error('--skip composer conflicts with pushing plugins: composer.json declares them, so plugin push runs Composer on the server. Skip plugin too, or drop --skip composer.');
+        }
         if (composerPushedByPlugins)
             skips.set('composer:push', { note: 'already pushed whole by plugins', status: 'pushed' });
         else if (!hasComposerJson)
@@ -174,28 +220,58 @@ export default class Push extends LoopressCommand {
         if (declaredPlugins.length === 0)
             skips.set('plugin:push', notConfigured);
         const capabilities = await this.capabilities();
+        // Installed and activated by this run's first step, before the steps that need them: a fresh
+        // site (CI, a new staging) gets ACF from loopress.json and its field groups in one push.
+        // composer.json records no active state, so its plugins stay inactive until --activate.
+        const activatedByPush = hasComposerJson || !isSelected('plugin:push') ? [] : declaredPlugins.filter((slug) => pinActive(this.localConfig.plugins?.[slug]));
         const missingDependencies = missingModule('dependencies', 'plugins and Composer', capabilities);
-        const steps = [
+        // A target left out by --only / --skip is reported skipped and never reaches the site checks,
+        // so it can't block the run.
+        const allSteps = [
             ...['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(PLUGIN_BACKED).map(([commandId, kind]) => {
+                const missing = missingIntegration(kind, capabilities);
+                // Not missing when one of the plugins that would provide it is activated earlier in the run.
+                const activated = missing?.plugins?.some((slug) => activatedByPush.includes(slug)) ?? false;
+                // A dry run activates nothing, so the site can't preview this step yet.
+                if (activated && this.dryRun)
+                    skips.set(commandId, { note: `${missing?.reason} until this push activates it, skipped`, status: 'skipped' });
+                return { commandId, missing: activated ? undefined : missing, skipUnused: true, used: projectUses(kind, this.localConfig) };
+            }),
             ...Object.entries(FULL_ONLY).map(([commandId, kind]) => ({
                 commandId,
                 missing: missingIntegration(kind, capabilities),
-                skipUnused: false,
+                skipUnused: true,
                 used: projectUses(kind, this.localConfig),
             })),
+            ...Object.entries(CORE_BACKED).map(([commandId, kind]) => ({ commandId, missing: undefined, skipUnused: true, 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) },
         ];
+        const steps = allSteps.filter((step) => isSelected(step.commandId));
         this.applySiteSteps(steps, skips, { fromComposer: hasComposerJson, plugins: declaredPlugins });
-        const stylesNote = await this.globalStylesSkipNote();
+        const stylesNote = isSelected('theme:style:push') ? await this.globalStylesSkipNote() : undefined;
         if (stylesNote)
             skips.set('theme:style:push', { note: stylesNote, status: 'skipped' });
+        for (const target of PUSH_TARGETS) {
+            // Composer left out of --only still runs when plugin push syncs composer.json: say so.
+            if (composerPushedByPlugins && target.commandId === 'composer:push')
+                continue;
+            if (!selected.has(target.id))
+                skips.set(target.commandId, { note: 'not selected, skipped', status: 'skipped' });
+        }
         return skips;
     }
+    // "<resources>: <why> on <site>. <fix>", for the refusal and for the --skip-unsupported warning.
+    unsupportedLine(commandId, missing, declared) {
+        const label = PUSH_TARGETS.find((target) => target.commandId === commandId)?.label;
+        const fix = integrationFix(missing, declared);
+        const fixSentence = fix ? ` ${fix}.` : '';
+        return `${label}: ${missing.reason} on ${this.siteConfig.name}.${fixSentence}`;
+    }
+    warnUnsupported() {
+        if (this.unsupported.length > 0) {
+            this.warn(`Skipped with --skip-unsupported, this site can't hold them:\n  ${this.unsupported.join('\n  ')}\nResources that depend on them (a page placing a block, code calling a hook) may not work until they are pushed.`);
+        }
+    }
 }

package/dist/commands/snippet/push.js

@@ -1,5 +1,5 @@
 import { Args } from '@oclif/core';
-import { readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { readFile, 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';
@@ -10,6 +10,7 @@ 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 { renameWithRetry } from '../../utils/rename-retry.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends PushCommand {
@@ -89,7 +90,7 @@ export default class Push extends PushCommand {
             return;
         const newPath = join(dir, `${canonicalBase}${ext}`);
         const newMetaPath = join(dir, `${canonicalBase}.json`);
-        await rename(snippet.path, newPath);
+        await renameWithRetry(snippet.path, newPath);
         await writeFile(newMetaPath, JSON.stringify(meta, null, 2) + '\n');
         await rm(oldMetaPath, { force: true });
     }

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

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

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

@@ -34,7 +34,7 @@ export default class Push extends PushCommand {
             throw error;
         }
         // Only the active theme's file is pushed, whatever else the directory holds.
-        const provider = getResourceStateProvider('theme-styles');
+        const provider = getResourceStateProvider('theme-style');
         const beforeState = await this.captureBeforePushState(provider, dir, (name) => name === stylesheet);
         if (this.dryRun)
             return { changes: this.previewChanges, file, status: 'dry-run' };

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

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

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

@@ -27,6 +27,8 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private keptFromSite;
     private previewChildTheme;
+    private readChildTheme;
 }
 export {};

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

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
+import { join } from 'node:path';
 import { activateTheme } from '../../../lib/capabilities.js';
 import {} from '../../../lib/diff-state.js';
+import { hasExclusions, isExcluded } from '../../../lib/exclude.js';
 import { errorMessage } from '../../../lib/narrow.js';
 import { logChanges, pushChanges, PushCommand } from '../../../lib/push-command.js';
 import { formatPageProblems } from '../../../utils/page-format.js';
@@ -39,8 +41,15 @@ export default class Push extends PushCommand {
         };
         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')}`);
+        this.warnEnvironmentUrls([
+            ...templates.map((template) => ({ id: `templates/${template.slug}`, value: template.html })),
+            ...parts.map((part) => ({ id: `parts/${part.slug}`, value: part.html })),
+        ]);
+        // The PUT replaces every file of the child theme: what the site has under a path this
+        // environment excludes (loopress.json) is sent back as it is, so it is left alone.
+        const kept = await this.keptFromSite(templatesPath, partsPath, templates, parts);
         if (this.dryRun) {
-            const changes = await this.previewChildTheme(templates, parts, css);
+            const changes = await this.previewChildTheme(templates, parts, css, kept);
             logChanges((message) => { this.log(message); }, changes.templates, 'templates/');
             logChanges((message) => { this.log(message); }, changes.parts, 'parts/');
             logChanges((message) => { this.log(message); }, changes.css, 'css/');
@@ -51,7 +60,7 @@ export default class Push extends PushCommand {
             }
             return { ...names, changes, status: 'dry-run' };
         }
-        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { ...css, parts, templates });
+        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { ...css, parts: [...parts, ...kept.parts], templates: [...templates, ...kept.templates] });
         await this.recordSuccess();
         this.log(`Child theme ${child.stylesheet} written.`);
         // Activated only when the project asks for it: a theme switch changes every per-theme setting.
@@ -83,15 +92,23 @@ export default class Push extends PushCommand {
             unknownBlocks,
         };
     }
-    // Same read and same refusal as previewRemote, one GET for templates, parts and CSS.
-    async previewChildTheme(templates, parts, css) {
-        let child;
-        try {
-            child = await this.wp.get(CHILD_THEME_ENDPOINT);
-        }
-        catch (error) {
-            this.error(`The site would refuse this push: ${errorMessage(error)}`);
-        }
+    // The site's templates and parts under an excluded path the project doesn't push. Refuses when
+    // the site can't be read: pushing blind would remove them.
+    async keptFromSite(templatesPath, partsPath, templates, parts) {
+        if (!hasExclusions())
+            return { parts: [], templates: [] };
+        const child = await this.readChildTheme();
+        const localTemplates = new Set(templates.map((template) => template.slug));
+        const localParts = new Set(parts.map((part) => part.slug));
+        return {
+            parts: child.parts.filter((part) => !localParts.has(part.slug) && isExcluded(join(partsPath, `${part.slug}.html`))),
+            templates: child.templates.filter((template) => !localTemplates.has(template.slug) && isExcluded(join(templatesPath, `${template.slug}.html`))),
+        };
+    }
+    // Same read and same refusal as previewRemote, one GET for templates, parts and CSS. Kept
+    // files are held back, they are neither changes nor removals.
+    async previewChildTheme(templates, parts, css, kept) {
+        const child = await this.readChildTheme();
         const localCss = new Map(css.blocks.map((block) => [`blocks/${block.name}.css`, sha256(block.css)]));
         if (css.style !== '')
             localCss.set('style.css', sha256(css.style));
@@ -100,14 +117,26 @@ export default class Push extends PushCommand {
             : [...localCss.keys()].toSorted((a, b) => a.localeCompare(b)).map((id) => ({ id, status: 'unknown' }));
         return {
             css: cssChanges,
-            parts: pushChanges(bySlug(parts), bySlug(child.parts), { mirror: true }),
-            templates: pushChanges(bySlug(templates), bySlug(child.templates), { mirror: true }),
+            parts: withoutKept(pushChanges(bySlug([...parts, ...kept.parts]), bySlug(child.parts), { mirror: true }), kept.parts),
+            templates: withoutKept(pushChanges(bySlug([...templates, ...kept.templates]), bySlug(child.templates), { mirror: true }), kept.templates),
         };
     }
+    async readChildTheme() {
+        try {
+            return await this.wp.get(CHILD_THEME_ENDPOINT);
+        }
+        catch (error) {
+            this.error(`The site would refuse this push: ${errorMessage(error)}`);
+        }
+    }
 }
 function bySlug(files) {
     return new Map(files.map(({ slug, ...rest }) => [slug, rest]));
 }
+function withoutKept(changes, kept) {
+    const slugs = new Set(kept.map((file) => file.slug));
+    return changes.filter((change) => !slugs.has(change.id));
+}
 function sha256(text) {
     return createHash('sha256').update(text, 'utf8').digest('hex');
 }

package/dist/commands/validate.js

@@ -11,6 +11,9 @@ export default class Validate extends Command {
             for (const problem of result.problems) {
                 this.log(`  ✗ ${problem.file}: ${problem.message}`);
             }
+            for (const warning of result.warnings) {
+                this.log(`  ! ${warning.file}: ${warning.message}`);
+            }
             this.log('');
             this.log(result.valid
                 ? `${result.checked} file(s) checked, no problems found.`

package/dist/lib/base.d.ts

@@ -3,6 +3,7 @@ import { type EnvironmentConfig } from '../types/config.js';
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
 import { type SiteCapabilities } from './capabilities.js';
 import { WpClient } from './wp-client.js';
+export declare function listrRenderer(silent: boolean): 'default' | 'silent' | 'simple';
 export declare abstract class LoopressCommand extends Command {
     static baseFlags: {
         env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -10,6 +11,10 @@ export declare abstract class LoopressCommand extends Command {
     static dryRunFlag: {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static honorsExclude: boolean;
+    static skipUnsupportedFlag: {
+        'skip-unsupported': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     static yesFlag: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
@@ -17,6 +22,7 @@ export declare abstract class LoopressCommand extends Command {
     protected localConfig: LoopressLocalConfig;
     protected overwrite: boolean;
     protected productionConfirmed: boolean;
+    protected projectEnvironments: EnvironmentConfig[];
     protected projectId: string;
     protected siteConfig: EnvironmentConfig;
     protected yes: boolean;
@@ -44,6 +50,7 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveOptionsPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     protected resolveThemeStylesPath(override?: string): string;
+    private assertSiteSupportsResource;
     private pickEnvironment;
     private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -8,11 +8,21 @@ import {} from '../types/config.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 import { pluralize } from '../utils/pluralize.js';
 import { resolveResourceDir } from '../utils/resource-dirs.js';
-import { getCapabilities } from './capabilities.js';
+import { commandResourceKind, getCapabilities, missingIntegration, unsupportedMessage } from './capabilities.js';
+import { declaredPlugins } from './declared-plugins.js';
+import { activateExclusions } from './exclude.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
 import { withoutSpinner } from './spinner.js';
 import { WpClient } from './wp-client.js';
+// Listr's default renderer wraps every label to the terminal width, so a terminal reporting no
+// width (columns 0 or undefined, e.g. `script` without a size) renders one letter per line. The
+// simple renderer prints plain lines and does not wrap.
+export function listrRenderer(silent) {
+    if (silent)
+        return 'silent';
+    return process.stdout.columns > 0 ? 'default' : 'simple';
+}
 export class LoopressCommand extends Command {
     // On every subclass without opt-in. Without it, commands target the "local" environment, so
     // reaching a remote site is always spelled out in the command itself.
@@ -24,6 +34,16 @@ export class LoopressCommand extends Command {
     static dryRunFlag = {
         'dry-run': Flags.boolean({ char: 'd', description: 'Show what would change without making changes' }),
     };
+    // Whether the environment's `exclude` globs in loopress.json apply (lib/exclude.ts): push and
+    // diff commands only, never pull.
+    static honorsExclude = false;
+    // Opt-in on push, pull, diff and promote: a resource the project uses but the site can't hold
+    // (see lib/capabilities.ts) is reported skipped, with a final warning, instead of failing the run.
+    static skipUnsupportedFlag = {
+        'skip-unsupported': Flags.boolean({
+            description: "Skip the resources the project uses but this site can't hold (a missing plugin, a Full feature on Light) instead of failing, and warn about each",
+        }),
+    };
     static yesFlag = {
         yes: Flags.boolean({ char: 'y', description: 'Answer yes to confirmation prompts' }),
     };
@@ -33,6 +53,8 @@ export class LoopressCommand extends Command {
     overwrite = false;
     // Set by PushCommand's hidden --production-confirmed, see there.
     productionConfirmed = false;
+    // Every environment of the project, the target included (see environment-urls.ts).
+    projectEnvironments = [];
     projectId;
     siteConfig;
     yes = false;
@@ -75,7 +97,15 @@ export class LoopressCommand extends Command {
         const resolved = this.resolveEnvironment(flags.env);
         this.siteConfig = resolved.env;
         this.projectId = resolved.projectId;
+        activateExclusions({
+            config: this.localConfig,
+            cwd: process.cwd(),
+            envName: this.siteConfig.name,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
+            honors: this.ctor.honorsExclude,
+        });
         await this.maybeAutoRotate();
+        await this.assertSiteSupportsResource();
     }
     // Silent, best-effort: a stale app password still works, so a failed rotation attempt
     // (offline, site down) just tries again on the next command instead of blocking this one.
@@ -128,7 +158,10 @@ export class LoopressCommand extends Command {
                     task.output = `Pulled: ${options.title(item)}`;
                 },
                 title: `Pull ${options.title(item)}`,
-            })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+            })), 
+            // Listr types the task wrapper per renderer, a union of renderer names does not fit it.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Listr ties the task wrapper type to one renderer
+            { renderer: listrRenderer(this.jsonEnabled()) }).run();
         });
         await this.removeOrphanedFiles(dir, orphans, options.orphanReason);
         this.log(options.pulledMessage);
@@ -187,6 +220,25 @@ export class LoopressCommand extends Command {
     resolveThemeStylesPath(override) {
         return resolveResourceDir('themeStyles', this.localConfig, override);
     }
+    // A command on a single kind of resource (`lps hook push`) says what `lps push` says when the
+    // site can't hold it, instead of failing on the 404. A site whose capabilities can't be read
+    // (too old a plugin, unreachable) lets the command run and report its own error.
+    async assertSiteSupportsResource() {
+        const kind = commandResourceKind(this.id);
+        if (!kind)
+            return;
+        let missing;
+        try {
+            missing = missingIntegration(kind, await this.capabilities());
+        }
+        catch {
+            return;
+        }
+        if (!missing)
+            return;
+        const declared = await declaredPlugins({ localConfig: this.localConfig, rootDir: this.rootDir, siteName: this.siteConfig.name });
+        this.error(unsupportedMessage(missing, this.siteConfig.name, declared));
+    }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];
         if (!env) {
@@ -204,6 +256,7 @@ export class LoopressCommand extends Command {
         if (!project) {
             this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
         }
+        this.projectEnvironments = Object.values(project.environments);
         const envNames = Object.keys(project.environments);
         if (envNames.length === 0) {
             this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);

package/dist/lib/capabilities.d.ts

@@ -36,6 +36,11 @@ export declare function integrationFix(missing: MissingIntegration, declared: {
     fromComposer: boolean;
     plugins: string[];
 }): string | undefined;
+export declare function commandResourceKind(commandId: string | undefined): ResourceDirKind | undefined;
+export declare function unsupportedMessage(missing: MissingIntegration, site: string, declared: {
+    fromComposer: boolean;
+    plugins: string[];
+}): string;
 export type ThemeActivation = {
     active: string;
     changed: boolean;

package/dist/lib/capabilities.js

@@ -78,6 +78,22 @@ export function integrationFix(missing, declared) {
     const where = declared.fromComposer ? `wpackagist-plugin/${first} in composer.json` : `"${first}" in loopress.json plugins`;
     return `Declare ${first}${or} (${where}), then activate it: ${activate(first)}`;
 }
+// The command topics that act on one kind of resource the site may be unable to hold
+// (`lps hook push`, `lps acf list`...), so they can say so instead of surfacing the 404. `publish`
+// goes through the console, not the site. `scf` is the alias of `acf`.
+const TOPIC_KINDS = { acf: 'acf', api: 'api', block: 'block', form: 'form', hook: 'hooks', page: 'page', pattern: 'pattern', scf: 'acf', snippet: 'snippets' };
+export function commandResourceKind(commandId) {
+    const [topic, action] = (commandId ?? '').split(':', 2);
+    if (!topic || !action || action === 'publish')
+        return undefined;
+    return TOPIC_KINDS[topic];
+}
+// "Not supported by <site>: <reason>. <fix>.", for the single-resource commands.
+export function unsupportedMessage(missing, site, declared) {
+    const fix = integrationFix(missing, declared);
+    const fixSentence = fix ? ` ${fix}.` : '';
+    return `Not supported by ${site}: ${missing.reason}.${fixSentence}`;
+}
 export async function activateTheme(wp, stylesheet) {
     const activation = await wp.post(THEME_ACTIVATE_ENDPOINT, { stylesheet });
     cache.delete(wp);

package/dist/lib/declared-plugins.d.ts

@@ -0,0 +1,9 @@
+import { type LoopressLocalConfig } from '../utils/loopress-config.js';
+export declare function declaredPlugins(options: {
+    localConfig: LoopressLocalConfig;
+    rootDir: string;
+    siteName: string;
+}): Promise<{
+    fromComposer: boolean;
+    plugins: string[];
+}>;