@loopress/cli 0.32.1 → 0.33.0

package/dist/config/project-config.manager.js

@@ -1,6 +1,8 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { isRecord } from '../lib/narrow.js';
 import { LOCAL_ENVIRONMENT_NAME } from '../lib/wp-client.js';
+import {} from '../types/config.js';
 import { toSlug } from '../utils/to-slug.js';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
@@ -55,10 +57,10 @@ export class ProjectConfigManager {
     // remembered choice is exactly the hidden state that sends a push to the wrong site.
     getDefaultEnvironment(projectId) {
         const environments = this.getProject(projectId)?.environments ?? {};
-        const names = Object.keys(environments);
         if (Object.hasOwn(environments, LOCAL_ENVIRONMENT_NAME))
-            return environments[LOCAL_ENVIRONMENT_NAME];
-        return names.length === 1 ? environments[names[0]] : null;
+            return environments[LOCAL_ENVIRONMENT_NAME] ?? null;
+        const [only, ...others] = Object.values(environments);
+        return others.length === 0 ? (only ?? null) : null;
     }
     getEnvironment(projectId, envName) {
         const project = this.getProject(projectId);
@@ -165,10 +167,7 @@ export class ProjectConfigManager {
         writeJsonFileAtomic(this.getConfigFilePath(), config);
     }
     isProjectConfig(value) {
-        if (typeof value !== 'object' || value === null)
-            return false;
-        const candidate = value;
-        return typeof candidate.name === 'string' && typeof candidate.environments === 'object' && candidate.environments !== null;
+        return isRecord(value) && typeof value.name === 'string' && isRecord(value.environments);
     }
     // Real CLI runs get this from the `init` hook (src/hooks/init.ts) before any command runs.
     // Throwing when it's unset (rather than falling back to a hardcoded path) surfaces tests that
@@ -179,25 +178,21 @@ export class ProjectConfigManager {
         return this.configDir;
     }
     sanitizeConfig(value) {
-        if (typeof value !== 'object' || value === null)
+        if (!isRecord(value))
             return { currentProject: null, projects: {} };
-        const candidate = value;
-        const telemetry = this.sanitizeTelemetry(candidate.telemetry);
+        const telemetry = this.sanitizeTelemetry(value.telemetry);
         return {
-            currentProject: this.sanitizeCurrentProject(candidate.currentProject),
-            projects: this.sanitizeProjects(candidate.projects),
+            currentProject: this.sanitizeCurrentProject(value.currentProject),
+            projects: this.sanitizeProjects(value.projects),
             ...(telemetry && { telemetry }),
         };
     }
     sanitizeCurrentProject(value) {
-        if (value === null || typeof value !== 'object')
-            return null;
-        const pointer = value;
         // A legacy `env` field, from when switch also picked the environment, is dropped here.
-        return typeof pointer.id === 'string' ? { id: pointer.id } : null;
+        return isRecord(value) && typeof value.id === 'string' ? { id: value.id } : null;
     }
     sanitizeProjects(value) {
-        if (typeof value !== 'object' || value === null)
+        if (!isRecord(value))
             return {};
         const projects = {};
         for (const [id, project] of Object.entries(value)) {
@@ -207,10 +202,7 @@ export class ProjectConfigManager {
         return projects;
     }
     sanitizeTelemetry(value) {
-        if (typeof value !== 'object' || value === null)
-            return undefined;
-        const candidate = value;
-        return typeof candidate.disabled === 'boolean' ? { disabled: candidate.disabled } : undefined;
+        return isRecord(value) && typeof value.disabled === 'boolean' ? { disabled: value.disabled } : undefined;
     }
 }
 export const configManager = new ProjectConfigManager();

package/dist/lib/api-client.js

@@ -1,6 +1,7 @@
-import got from 'got';
+import got, {} from 'got';
+import { errorMessage, isRecord } from './narrow.js';
 import { withSpinner } from './spinner.js';
-import { REQUEST_TIMEOUT_MS } from './wp-client.js';
+import { parseBody, REQUEST_TIMEOUT_MS, responseOf } from './wp-client.js';
 export const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
 /**
  * HTTP client for the Loopress cloud API (projects, environments, credentials).
@@ -31,6 +32,8 @@ export class ApiClient {
     async request(method, path, json) {
         try {
             const response = await withSpinner('Waiting for the Loopress API', async () => this.client(path, { json, method }));
+            // The API contract boundary: each endpoint's shape is the caller's `T`, not checked here.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- see above
             return (response.body ? JSON.parse(response.body) : undefined);
         }
         catch (error) {
@@ -39,41 +42,33 @@ export class ApiClient {
     }
 }
 function formatApiError(error, url, timeoutMs) {
-    const err = error;
-    const status = err.response?.statusCode;
+    const { body, statusCode: status } = responseOf(error);
     if (status === 401) {
         return `Not logged in or session expired on ${url}. Run \`lps login\` again.`;
     }
-    const reason = nestErrorMessage(err.response?.body);
+    const reason = nestErrorMessage(body);
     if (status === 403) {
         // An empty body (not just a missing one) falls back to got's message too, never a bare ": ".
-        const body = err.response?.body === '' ? undefined : err.response?.body;
-        return `Request rejected (${status}) on ${url}: ${reason ?? body ?? err.message}`;
+        return `Request rejected (${status}) on ${url}: ${reason ?? (body === '' ? undefined : body) ?? errorMessage(error)}`;
     }
     // Any other API refusal (a 400 validation error, a 409 conflict) carries its explanation in
     // the body; got's own message ("Request failed with status code 400") never does.
     if (status !== undefined && reason) {
         return `Request failed (${status}) on ${url}: ${reason}`;
     }
-    if (err.name === 'TimeoutError') {
+    if (isRecord(error) && error.name === 'TimeoutError') {
         return `Request timed out after ${timeoutMs / 1000}s on ${url}. Check your network connection, or the Loopress API may be temporarily unreachable.`;
     }
-    return err.message ?? String(error);
+    return errorMessage(error);
 }
 // NestJS's HttpException body: `{statusCode, message, error}`, where `message` is a list for a
 // ValidationPipe failure (one entry per invalid field).
 function nestErrorMessage(body) {
-    if (!body)
-        return undefined;
-    try {
-        const { message } = JSON.parse(body);
-        if (typeof message === 'string' && message.trim())
-            return message;
-        if (Array.isArray(message) && message.length > 0)
-            return message.join('; ');
-    }
-    catch {
-        // not JSON (a proxy's HTML error page): nothing to extract
-    }
+    // Not JSON (a proxy's HTML error page) reads as no fields: nothing to extract.
+    const { message } = parseBody(body);
+    if (typeof message === 'string' && message.trim())
+        return message;
+    if (Array.isArray(message) && message.length > 0)
+        return message.join('; ');
     return undefined;
 }

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,6 +1,7 @@
 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 abstract class LoopressCommand extends Command {
     static baseFlags: {
@@ -22,6 +23,7 @@ export declare abstract class LoopressCommand extends Command {
     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 +44,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,13 +1,14 @@
 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 { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
 import { withoutSpinner } from './spinner.js';
@@ -49,10 +50,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,
@@ -178,13 +187,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) {

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-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';
@@ -87,7 +89,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 +181,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.js

@@ -1,5 +1,6 @@
 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
@@ -13,18 +14,17 @@ export function resolveResourceTypes(only, skip = []) {
 // 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' },
         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' },
+        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(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
+        snippets: { commandId: 'snippet:push', path: join(cwd, resolveResourceDir('snippets', localConfig)), type: 'snippets' },
     };
     return types
         .map((type) => candidates[type])

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

@@ -16,12 +16,12 @@ export type DiffJson = {
 };
 export type DiffTarget = {
     left: () => Promise<ResourceState>;
-    optional?: boolean;
     resource: string;
     right: () => Promise<ResourceState>;
+    skip?: boolean;
     title: string;
 };
-type DiffSides = {
+export type DiffSides = {
     againstWp: undefined | WpClient;
     leftLabel: string;
     rightHeading: string;
@@ -48,4 +48,3 @@ export declare function resourceDiffCommand(resource: string, options: {
     description: string;
     pathNoun: string;
 }): typeof DiffCommand;
-export {};

package/dist/lib/diff-command.js

@@ -4,7 +4,7 @@ import { configManager } from '../config/project-config.manager.js';
 import { resolveResourceDir } from '../utils/resource-dirs.js';
 import { LoopressCommand } from './base.js';
 import { compareStates, isEmptyDiff } from './diff-state.js';
-import { INTEGRATION_MISSING } from './plugin-detection.js';
+import { errorMessage } from './narrow.js';
 import { composerLocalState, composerRemoteState, getResourceStateProvider } from './resource-state.js';
 import { WpClient } from './wp-client.js';
 const c = ux.colorize;
@@ -23,10 +23,11 @@ export class DiffCommand extends LoopressCommand {
         // than being prefixed with the cwd, so Composer is read from the same place as the
         // file-backed resources.
         const localRoot = resolve(process.cwd(), this.rootDir);
+        const { againstWp } = sides;
         return {
             left: async () => composerRemoteState(this.wp),
             resource: 'composer',
-            right: sides.againstWp ? async () => composerRemoteState(sides.againstWp) : async () => composerLocalState(localRoot),
+            right: againstWp ? async () => composerRemoteState(againstWp) : async () => composerLocalState(localRoot),
             title: 'Composer',
         };
     }
@@ -37,10 +38,11 @@ export class DiffCommand extends LoopressCommand {
             this.error('A [PATH] argument cannot be combined with --against: --against compares two environments, not local files.');
         }
         const dir = resolveResourceDir(provider.dirKind, this.localConfig, dirOverride);
+        const { againstWp } = sides;
         return {
             left: async () => provider.remote(this.wp, sides.warn, dir),
             resource: provider.resource,
-            right: sides.againstWp ? async () => provider.remote(sides.againstWp, sides.warn, dir) : async () => provider.local(dir, sides.warn),
+            right: againstWp ? async () => provider.remote(againstWp, sides.warn, dir) : async () => provider.local(dir, sides.warn, this.wp),
             title: provider.title,
         };
     }
@@ -113,6 +115,9 @@ export class DiffCommand extends LoopressCommand {
     // Fetches and compares one target. No output (so targets can run concurrently); `report`
     // renders `stateDiff` afterwards in a fixed order.
     async computeResource(target, sides) {
+        const empty = { added: [], changed: [], removed: [] };
+        if (target.skip)
+            return { drift: false, json: empty, resource: target.resource, skipped: true, title: target.title };
         try {
             const [leftState, rightState] = await Promise.all([target.left(), target.right()]);
             const stateDiff = compareStates(leftState, rightState, { left: sides.leftLabel, right: sides.rightLabel });
@@ -125,10 +130,7 @@ export class DiffCommand extends LoopressCommand {
             };
         }
         catch (error) {
-            const { message } = error;
-            const empty = { added: [], changed: [], removed: [] };
-            if (target.optional && INTEGRATION_MISSING.test(message))
-                return { drift: false, json: empty, resource: target.resource, skipped: true, title: target.title };
+            const message = errorMessage(error);
             return { drift: false, json: { ...empty, error: message }, resource: target.resource, title: target.title };
         }
     }

package/dist/lib/diff-state.js

@@ -1,11 +1,10 @@
 import { createTwoFilesPatch } from 'diff';
 import microdiff from 'microdiff';
 import { isDeepStrictEqual } from 'node:util';
+import { isRecord } from './narrow.js';
 const MAX_VALUE_LENGTH = 200;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function formatValue(value) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- typed as string, but JSON.stringify returns undefined for `undefined` (a removed field)
     const text = JSON.stringify(value) ?? String(value);
     return text.length > MAX_VALUE_LENGTH ? `${text.slice(0, MAX_VALUE_LENGTH - 1)}…` : text;
 }

package/dist/lib/load-files.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
+import { errorMessage } from './narrow.js';
 import { readdirTolerant, walkFiles } from './readdir-tolerant.js';
 // Loads every `<extension>` file of a directory through `parse`. One file is read in
 // isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
@@ -15,7 +16,7 @@ export async function loadFiles(dir, options) {
             items.push(options.parse(await readFile(filePath, 'utf8'), filePath));
         }
         catch (error) {
-            options.onSkip(`Skipping "${filePath}": ${error.message}`);
+            options.onSkip(`Skipping "${filePath}": ${errorMessage(error)}`);
         }
     }
     return items;