@loopress/cli 0.32.2 → 0.34.0

package/dist/lib/app-build.js

@@ -2,6 +2,8 @@ import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { isOneOf } from './narrow.js';
 import { withSpinner } from './spinner.js';
 // The package managers `lps app push` may spawn. An allowlist, not the raw `packageManager`
 // field: the name ends up as a process to run.
@@ -13,6 +15,8 @@ const LOCKFILES = [
     ['bun.lockb', 'bun'],
     ['package-lock.json', 'npm'],
 ];
+// Only the fields read here; the rest of package.json is the app's own business.
+const PACKAGE_JSON = z.looseObject({ packageManager: z.string().optional(), scripts: z.record(z.string(), z.string()).optional() });
 // How many trailing lines of build output a failure message carries.
 const OUTPUT_TAIL_LINES = 20;
 // `packageManager` field first (corepack's own source of truth), then the nearest lockfile
@@ -20,7 +24,7 @@ const OUTPUT_TAIL_LINES = 20;
 // then npm.
 export function detectPackageManager(appDir, packageManagerField) {
     const fromField = packageManagerField?.split('@', 1)[0];
-    if (PACKAGE_MANAGERS.includes(fromField))
+    if (isOneOf(PACKAGE_MANAGERS, fromField))
         return fromField;
     for (let dir = appDir;; dir = dirname(dir)) {
         const lockfile = LOCKFILES.find(([file]) => existsSync(join(dir, file)));
@@ -38,7 +42,7 @@ export async function buildApp(appDir, onStart) {
     const packageJsonPath = join(appDir, 'package.json');
     if (!existsSync(packageJsonPath))
         return undefined;
-    const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    const pkg = PACKAGE_JSON.parse(JSON.parse(await readFile(packageJsonPath, 'utf8')));
     if (!pkg.scripts?.build)
         return undefined;
     const pm = detectPackageManager(appDir, pkg.packageManager);

package/dist/lib/app-manifest.js

@@ -44,9 +44,9 @@ export function computeBuildId(files) {
 }
 function normalizeAssetUrl(url) {
     let path = url.trim();
-    const schemeMatch = /^(?:[a-z]+:)?\/\/[^/]+(\/.*)$/i.exec(path);
+    const schemeMatch = /^(?:[a-z]+:)?\/\/[^/]+(\/.*)$/i.exec(path)?.[1];
     if (schemeMatch)
-        path = schemeMatch[1];
+        path = schemeMatch;
     path = path.replace(/^\.?\//, '');
     return path;
 }
@@ -57,17 +57,17 @@ export function deriveEntry(indexHtml) {
     for (const tag of indexHtml.match(/<script\b[^>]*>/gi) ?? []) {
         if (!/\btype=["']module["']/i.test(tag))
             continue;
-        const src = /\bsrc=["']([^"']+)["']/i.exec(tag);
+        const src = /\bsrc=["']([^"']+)["']/i.exec(tag)?.[1];
         if (src)
-            scripts.push(normalizeAssetUrl(src[1]));
+            scripts.push(normalizeAssetUrl(src));
     }
     const styles = [];
     for (const tag of indexHtml.match(/<link\b[^>]*>/gi) ?? []) {
         if (!/\brel=["']stylesheet["']/i.test(tag))
             continue;
-        const href = /\bhref=["']([^"']+)["']/i.exec(tag);
+        const href = /\bhref=["']([^"']+)["']/i.exec(tag)?.[1];
         if (href)
-            styles.push(normalizeAssetUrl(href[1]));
+            styles.push(normalizeAssetUrl(href));
     }
     return { scripts, styles };
 }

package/dist/lib/base.d.ts

@@ -1,7 +1,9 @@
 import { Command } from '@oclif/core';
 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>;
@@ -9,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>;
     };
@@ -16,12 +22,14 @@ 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;
     private wpClient?;
     protected get rootDir(): string;
     protected get wp(): WpClient;
+    protected capabilities(): Promise<SiteCapabilities>;
     init(): Promise<void>;
     protected maybeAutoRotate(): Promise<void>;
     protected pullDirectory<T>(dir: string, items: T[], orphans: string[], options: {
@@ -42,7 +50,6 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveOptionsPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     protected resolveThemeStylesPath(override?: string): string;
-    protected warnRemovedSeoModule(): void;
     private pickEnvironment;
     private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -1,17 +1,27 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
-import { existsSync } from 'node:fs';
 import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
+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 { 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.
@@ -23,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' }),
     };
@@ -32,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;
@@ -49,10 +71,18 @@ export class LoopressCommand extends Command {
         }
         return this.wpClient;
     }
+    // What the targeted site can do, read once per process (see lib/capabilities.ts).
+    async capabilities() {
+        return getCapabilities(this.wp, this.siteConfig.name);
+    }
     async init() {
         await super.init();
+        // oclif types `this.ctor` as the base `typeof Command`, and parse() can't infer flags from a
+        // runtime-chosen subclass: both casts state what every LoopressCommand subclass declares.
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
         const { flags } = (await this.parse({
             args: this.ctor.args,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
             baseFlags: this.ctor.baseFlags,
             enableJsonFlag: this.ctor.enableJsonFlag,
             flags: this.ctor.flags,
@@ -66,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
@@ -119,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);
@@ -178,13 +218,6 @@ export class LoopressCommand extends Command {
     resolveThemeStylesPath(override) {
         return resolveResourceDir('themeStyles', this.localConfig, override);
     }
-    // `lps seo` was removed: a leftover seo/ folder or seoDir key would otherwise be silently
-    // ignored by `lps pull` / `lps push`. Remove once projects have had a release to migrate.
-    warnRemovedSeoModule() {
-        if (!('seoDir' in this.localConfig) && !existsSync(join(this.rootDir, 'seo')))
-            return;
-        this.warn('The SEO module was removed: seo/ is no longer pulled or pushed. Track SEO plugin settings with `lps option add rank-math-options-titles` (or `wpseo_titles`), then delete seo/ and any seoDir key from loopress.json.');
-    }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];
         if (!env) {
@@ -202,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/bootstrap-full-install.js

@@ -1,6 +1,8 @@
 import { launchLocalBrowser } from './browser-launch.js';
 import { downloadLatestFullZip } from './github-release.js';
+import { errorMessage } from './narrow.js';
 import { createTempAdmin, deleteTempAdmin } from './temp-admin.js';
+import {} from './wp-client.js';
 /**
  * Installs and activates Loopress Full on a site that doesn't have it yet: downloads the
  * latest release zip, creates a temporary admin (the only way to get `install_plugins` from
@@ -29,7 +31,7 @@ export async function bootstrapLoopressFull(wp, siteUrl, log) {
         // default termination runs with the right exit code.
         removeTempAdmin()
             .catch((error) => {
-            log(`Could not remove the temporary admin account "${admin.username}"; remove it manually in wp-admin. (${error.message})`);
+            log(`Could not remove the temporary admin account "${admin.username}"; remove it manually in wp-admin. (${errorMessage(error)})`);
         })
             .finally(() => {
             process.removeListener('SIGINT', onSignal);
@@ -65,12 +67,12 @@ export async function bootstrapLoopressFull(wp, siteUrl, log) {
         process.removeListener('SIGTERM', onSignal);
     }
     const manualFallback = `Install it manually: upload ${zipPath} at ${siteUrl}/wp-admin/plugin-install.php?tab=upload`;
-    if (installError && cleanupError) {
-        throw new Error(`Could not install Loopress Full automatically, and the temporary admin account could not be removed (${cleanupError.message}). ${manualFallback}`, { cause: installError });
+    if (installError !== undefined && cleanupError !== undefined) {
+        throw new Error(`Could not install Loopress Full automatically, and the temporary admin account could not be removed (${errorMessage(cleanupError)}). ${manualFallback}`, { cause: installError });
     }
-    if (cleanupError)
-        throw cleanupError;
-    if (installError) {
+    if (cleanupError !== undefined)
+        throw cleanupError instanceof Error ? cleanupError : new Error(errorMessage(cleanupError));
+    if (installError !== undefined) {
         throw new Error(`Could not install Loopress Full automatically. ${manualFallback}`, { cause: installError });
     }
 }

package/dist/lib/capabilities.d.ts

@@ -0,0 +1,44 @@
+import { type ResourceDirKind } from '../utils/resource-dirs.js';
+import { type WpClient } from './wp-client.js';
+export type SiteCapabilities = {
+    edition: 'full' | 'light';
+    environmentType: string;
+    integrations: {
+        acf: boolean;
+        form: boolean;
+        snippets?: boolean | undefined;
+    };
+    modules: string[];
+    theme: {
+        active: string;
+        child?: null | undefined | {
+            active: boolean;
+            exists: boolean;
+            stylesheet: string;
+        };
+        isBlock: boolean;
+        template: string;
+    };
+    version: string;
+};
+export declare const CAPABILITIES_ENDPOINT = "loopress/v1/capabilities";
+export declare const THEME_ACTIVATE_ENDPOINT = "loopress/v1/theme/activate";
+export declare function getCapabilities(wp: WpClient, site: string): Promise<SiteCapabilities>;
+export type MissingIntegration = {
+    fix?: string;
+    needsFull?: true;
+    plugins?: string[];
+    reason: string;
+};
+export declare function missingModule(module: string, what: string, { modules }: SiteCapabilities): MissingIntegration | undefined;
+export declare function missingIntegration(kind: ResourceDirKind, capabilities: SiteCapabilities): MissingIntegration | undefined;
+export declare function integrationFix(missing: MissingIntegration, declared: {
+    fromComposer: boolean;
+    plugins: string[];
+}): string | undefined;
+export type ThemeActivation = {
+    active: string;
+    changed: boolean;
+    previous: string;
+};
+export declare function activateTheme(wp: WpClient, stylesheet: string): Promise<ThemeActivation>;

package/dist/lib/capabilities.js

@@ -0,0 +1,85 @@
+import {} from '../utils/resource-dirs.js';
+import { isNotFoundError } from './wp-client.js';
+export const CAPABILITIES_ENDPOINT = 'loopress/v1/capabilities';
+export const THEME_ACTIVATE_ENDPOINT = 'loopress/v1/theme/activate';
+// One request per site and per process: the aggregate commands ask about every resource.
+const cache = new WeakMap();
+// `site` names it in the error, the environment name or its URL.
+export async function getCapabilities(wp, site) {
+    let capabilities = cache.get(wp);
+    if (!capabilities) {
+        const tooOld = `The Loopress plugin on ${site} is too old for this CLI. Update it, then try again.`;
+        capabilities = wp
+            .get(CAPABILITIES_ENDPOINT)
+            .catch((error) => {
+            if (isNotFoundError(error))
+                throw new Error(tooOld, { cause: error });
+            throw error;
+        })
+            .then((result) => {
+            // A plugin from before `modules` answers without it.
+            if (!Array.isArray(result.modules))
+                throw new Error(tooOld);
+            return result;
+        });
+        cache.set(wp, capabilities);
+    }
+    return capabilities;
+}
+// `what` needs the `module` feature of Loopress Full.
+export function missingModule(module, what, { modules }) {
+    return modules.includes(module) ? undefined : { fix: 'Install Loopress Full', needsFull: true, reason: `${what} need Loopress Full` };
+}
+const needsModule = (module, what) => (capabilities) => missingModule(module, what, capabilities);
+// The kinds of resource a site may be unable to hold. Every other kind needs nothing from it.
+const INTEGRATION_CHECKS = {
+    acf: ({ integrations }) => (integrations.acf ? undefined : { plugins: ['advanced-custom-fields'], reason: 'ACF is not active' }),
+    api: needsModule('api', 'API routes'),
+    block: needsModule('blocks', 'dynamic blocks'),
+    blockCss: needsModule('pages', 'templates and parts'),
+    css: needsModule('pages', 'templates and parts'),
+    form: ({ integrations }) => (integrations.form ? undefined : { plugins: ['wpforms-lite'], reason: 'no supported form plugin is active' }),
+    hooks: needsModule('hooks', 'hooks'),
+    page: needsModule('pages', 'pages'),
+    part: needsModule('pages', 'templates and parts'),
+    pattern: needsModule('pages', 'block patterns'),
+    snippets(capabilities) {
+        const missing = missingModule('snippets', 'snippets', capabilities);
+        if (missing)
+            return missing;
+        return capabilities.integrations.snippets === true
+            ? undefined
+            : { plugins: ['code-snippets', 'insert-headers-and-footers'], reason: 'no supported snippet plugin is active' };
+    },
+    template: needsModule('pages', 'templates and parts'),
+    themeStyles: ({ theme }) => (theme.isBlock ? undefined : { reason: `the active theme "${theme.active}" is a classic theme` }),
+};
+// Why the site can't hold this kind of resource, or undefined when it can (or the kind needs
+// nothing from the site).
+export function missingIntegration(kind, capabilities) {
+    return INTEGRATION_CHECKS[kind]?.(capabilities);
+}
+// How to fix a missing integration, given the plugins the project declares (composer.json, or
+// loopress.json without one): declared but inactive needs activating, otherwise declaring.
+export function integrationFix(missing, declared) {
+    if (missing.fix)
+        return missing.fix;
+    if (!missing.plugins)
+        return undefined;
+    // composer.json records no active state, loopress.json pins it per plugin.
+    const activate = (plugin) => declared.fromComposer ? '`lps plugin push --activate`' : `"${plugin}": {"active": true, ...} in loopress.json, then \`lps plugin push\``;
+    const plugin = missing.plugins.find((candidate) => declared.plugins.includes(candidate));
+    if (plugin)
+        return `The project declares ${plugin}, activate it: ${activate(plugin)}`;
+    const [first, ...alternatives] = missing.plugins;
+    if (first === undefined)
+        return undefined;
+    const or = alternatives.length > 0 ? ` (or ${alternatives.join(', ')})` : '';
+    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)}`;
+}
+export async function activateTheme(wp, stylesheet) {
+    const activation = await wp.post(THEME_ACTIVATE_ENDPOINT, { stylesheet });
+    cache.delete(wp);
+    return activation;
+}

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

@@ -9,6 +9,8 @@ import { LoopressCommand } from './base.js';
 import { basenameKey, findOrphanedFiles } from './find-orphaned-files.js';
 import { isInteractive } from './interactive.js';
 import { loadFiles } from './load-files.js';
+import { errorMessage } from './narrow.js';
+import {} from './php-files-command.js';
 import { PushCommand } from './push-command.js';
 import { getResourceStateProvider } from './resource-state.js';
 import { isApplicative404, isNotFoundError } from './wp-client.js';
@@ -44,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);
@@ -87,7 +92,7 @@ export function declaredPushCommand(spec, description) {
                     task.output = `Pushed: ${slug}`;
             }
             catch (error) {
-                this.reportTaskFailure(`Failed to push ${slug}: ${error.message}`, error, task);
+                this.reportTaskFailure(`Failed to push ${slug}: ${errorMessage(error)}`, error, task);
             }
         }
     }
@@ -179,7 +184,7 @@ export function declaredRmCommand(spec, description, keptNote) {
                 await this.wp.delete(itemEndpoint(spec, slug));
             }
             catch (error) {
-                const notFound = `${spec.noun[0].toUpperCase()}${spec.noun.slice(1)} not found`;
+                const notFound = `${spec.noun.charAt(0).toUpperCase()}${spec.noun.slice(1)} not found`;
                 if (isApplicative404(error, notFound))
                     this.error(`${spec.noun} ${slug} is not managed by Loopress on ${url}.`);
                 throw error;

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

@@ -1,35 +1,33 @@
 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
 // directories which are all optional. `plugins` watches the whole `loopress.json` lockfile since
 // the plugin manifest is a field in it, not its own directory.
 export function buildWatchTargets(types, localConfig, cwd) {
-    const rootDir = join(cwd, localConfig.rootDir ?? '.');
     const candidates = {
-        api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        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(rootDir, localConfig.hooksDir ?? 'hooks'), type: 'hooks' },
-        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), 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(rootDir, localConfig.snippetsDir ?? 'snippets'), 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);
     });

package/dist/lib/diff-command.d.ts

@@ -1,4 +1,5 @@
 import { LoopressCommand } from './base.js';
+import { type MissingIntegration } from './capabilities.js';
 import { type ResourceState, type StateChange } from './diff-state.js';
 import { type ResourceStateProvider } from './resource-state.js';
 import { WpClient } from './wp-client.js';
@@ -6,7 +7,10 @@ export type ResourceDiffJson = {
     added: string[];
     changed: StateChange[];
     error?: string;
+    heldBack?: string[];
+    reason?: string;
     removed: string[];
+    status?: 'skipped';
 };
 export type DiffJson = {
     drift: boolean;
@@ -15,13 +19,20 @@ export type DiffJson = {
     right: string;
 };
 export type DiffTarget = {
+    heldBackFrom?: (() => Promise<ResourceState>) | undefined;
+    isHeldBack?: ((id: string) => boolean) | undefined;
     left: () => Promise<ResourceState>;
-    optional?: boolean;
     resource: string;
     right: () => Promise<ResourceState>;
+    skip?: boolean;
     title: string;
+    unsupported?: {
+        fix?: string | undefined;
+        missing: MissingIntegration;
+        reason: string;
+    };
 };
-type DiffSides = {
+export type DiffSides = {
     againstWp: undefined | WpClient;
     leftLabel: string;
     rightHeading: string;
@@ -32,15 +43,19 @@ export declare abstract class DiffCommand extends LoopressCommand {
     static againstFlag: {
         against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static honorsExclude: boolean;
     protected composerTarget(sides: DiffSides): DiffTarget;
     protected providerTarget(provider: ResourceStateProvider, sides: DiffSides, dirOverride?: string): DiffTarget;
     protected report(targets: DiffTarget[], sides: DiffSides): Promise<DiffJson>;
+    protected reportDrift(result: DiffJson): Promise<void>;
     protected resolveSides(against: string | undefined): DiffSides;
     abstract run(): Promise<DiffJson>;
     private computeResource;
     private out;
     private renderFailure;
+    private renderHeldBack;
     private renderSection;
+    private renderSkipped;
     private wpForEnvironment;
 }
 export declare function resourceDiffCommand(resource: string, options: {
@@ -48,4 +63,5 @@ export declare function resourceDiffCommand(resource: string, options: {
     description: string;
     pathNoun: string;
 }): typeof DiffCommand;
-export {};
+export declare function excludedFileFor(dir: string, id: string, provider: Pick<ResourceStateProvider, 'fileExtension' | 'fileName'>): boolean;
+export declare function sharedReads(wp: WpClient): WpClient;