@loopress/cli 0.33.0 → 0.34.0

package/dist/commands/push.d.ts

@@ -2,6 +2,7 @@ import { LoopressCommand } from '../lib/base.js';
 type PushTargetResult = {
     error?: string;
     label: string;
+    reason?: string;
     result?: unknown;
     status: 'failed' | 'pushed' | 'skipped';
 };
@@ -14,16 +15,24 @@ export default class Push extends LoopressCommand {
     static examples: string[];
     static flags: {
         overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'skip-unsupported': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        only: ReturnType<typeof import("@oclif/core/flags").string>;
+        skip: ReturnType<typeof import("@oclif/core/flags").string>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    private skipUnsupported;
+    private readonly unsupported;
     run(): Promise<PushResult>;
     private applySiteSteps;
     private buildArgv;
     private composerJsonPath;
     private declaredPlugins;
+    private doneMessage;
     private globalStylesSkipNote;
     private guardProductionPush;
     private skippedTargets;
+    private unsupportedLine;
+    private warnUnsupported;
 }
 export {};

package/dist/commands/push.js

@@ -7,7 +7,9 @@ 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 { 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,68 @@ 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'));
         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 +94,16 @@ 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();
                 this.error(`${target.label} failed to push: ${message}.${skippedNote}`);
             }
         }
-        this.log(this.dryRun ? '\nEvery resource would push.' : '\nAll resources pushed.');
+        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 +113,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 +159,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 +187,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 +209,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/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;

package/dist/lib/base.js

@@ -9,10 +9,19 @@ 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 { 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 +33,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 +52,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,6 +96,13 @@ 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();
     }
     // Silent, best-effort: a stale app password still works, so a failed rotation attempt
@@ -128,7 +156,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);
@@ -204,6 +235,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/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[];
+}>;

package/dist/lib/declared-plugins.js

@@ -0,0 +1,21 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseComposerJson, wpackagistRequire } from '../utils/composer.js';
+import {} from '../utils/loopress-config.js';
+import { isLocalEnvironment } from './wp-client.js';
+// 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.
+export async function declaredPlugins(options) {
+    const path = resolve(process.cwd(), options.rootDir, 'composer.json');
+    if (!existsSync(path))
+        return { fromComposer: false, plugins: Object.keys(options.localConfig.plugins ?? {}) };
+    try {
+        const composerJson = parseComposerJson(await readFile(path, 'utf8'));
+        return { fromComposer: true, plugins: Object.keys(wpackagistRequire(composerJson, 'plugin', isLocalEnvironment(options.siteName))) };
+    }
+    catch {
+        return { fromComposer: true, plugins: [] };
+    }
+}

package/dist/lib/declared-type-command.js

@@ -46,6 +46,9 @@ export function declaredPushCommand(spec, description) {
                 parse: (raw, filePath) => parseDeclaredFile(spec, filePath, raw),
             });
             this.log(`Found ${pluralize(items.length, spec.noun, spec.plural)} to push`);
+            // Patterns carry block markup, the other declared types only registration arguments.
+            if (spec.cliName === 'pattern')
+                this.warnEnvironmentUrls(items.map((item) => ({ id: `${spec.plural}/${item.slug}`, value: item.args })));
             const pushed = [];
             await this.runPushTasks(items, (item) => item.slug, async (item, task) => {
                 await this.pushItem(item, task);

package/dist/lib/dev-watch.d.ts

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'blocks' | 'css' | 'hooks' | 'pages' | 'parts' | 'plugins' | 'snippets' | 'templates';
+export type ResourceType = 'api' | 'block' | 'css' | 'hook' | 'page' | 'part' | 'plugin' | 'snippet' | 'template';
 export declare const RESOURCE_TYPES: ResourceType[];
 export type WatchTarget = {
     commandId: string;

package/dist/lib/dev-watch.js

@@ -2,12 +2,10 @@ import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
 import {} from '../utils/loopress-config.js';
 import { resolveResourceDir } from '../utils/resource-dirs.js';
-export const RESOURCE_TYPES = ['snippets', 'templates', 'parts', 'css', 'blocks', 'pages', 'api', 'hooks', 'plugins'];
-// `only` narrows the default set, `skip` then removes from whatever that set is, same
-// precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
+import { selectResources } from './resource-selection.js';
+export const RESOURCE_TYPES = ['snippet', 'template', 'part', 'css', 'block', 'page', 'api', 'hook', 'plugin'];
 export function resolveResourceTypes(only, skip = []) {
-    const base = only && only.length > 0 ? only : RESOURCE_TYPES;
-    return base.filter((type) => !skip.includes(type));
+    return selectResources(RESOURCE_TYPES, only, skip);
 }
 // One target per requested type that actually has something to watch: a missing directory (no
 // `api/` folder yet) or an empty plugin manifest is left out silently, matching `push`'s own
@@ -17,19 +15,19 @@ export function buildWatchTargets(types, localConfig, cwd) {
     const candidates = {
         api: { commandId: 'api:push', path: join(cwd, resolveResourceDir('api', localConfig)), type: 'api' },
         // The theme CSS is bundled into the child theme with the templates, by the same push.
-        blocks: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('blockCss', localConfig)), type: 'blocks' },
+        block: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('blockCss', localConfig)), type: 'block' },
         css: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('css', localConfig)), type: 'css' },
-        hooks: { commandId: 'hook:push', path: join(cwd, resolveResourceDir('hooks', localConfig)), type: 'hooks' },
-        pages: { commandId: 'page:push', path: join(cwd, resolveResourceDir('page', localConfig)), type: 'pages' },
-        plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
-        parts: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('part', localConfig)), type: 'parts' },
-        templates: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('template', localConfig)), type: 'templates' },
-        snippets: { commandId: 'snippet:push', path: join(cwd, resolveResourceDir('snippets', localConfig)), type: 'snippets' },
+        hook: { commandId: 'hook:push', path: join(cwd, resolveResourceDir('hooks', localConfig)), type: 'hook' },
+        page: { commandId: 'page:push', path: join(cwd, resolveResourceDir('page', localConfig)), type: 'page' },
+        plugin: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugin' },
+        part: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('part', localConfig)), type: 'part' },
+        template: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('template', localConfig)), type: 'template' },
+        snippet: { commandId: 'snippet:push', path: join(cwd, resolveResourceDir('snippets', localConfig)), type: 'snippet' },
     };
     return types
         .map((type) => candidates[type])
         .filter((target) => {
-        if (target.type === 'plugins')
+        if (target.type === 'plugin')
             return Object.keys(localConfig.plugins ?? {}).length > 0;
         return existsSync(target.path);
     });