@loopress/cli 0.32.2 → 0.34.0

package/dist/commands/content/copy.js

@@ -2,10 +2,14 @@ import { confirm } from '@inquirer/prompts';
 import { Args, Flags } from '@oclif/core';
 import { configManager } from '../../config/project-config.manager.js';
 import { LoopressCommand } from '../../lib/base.js';
+import { activateTheme, getCapabilities } from '../../lib/capabilities.js';
 import { isInteractive } from '../../lib/interactive.js';
 import { stdoutToStderr } from '../../lib/json-delegation.js';
 import { isLocalEnvironment, LOCAL_ENVIRONMENT_NAME, WpClient } from '../../lib/wp-client.js';
+import {} from '../../types/plugin.js';
+import { parseInstalledPlugins } from '../../utils/plugins.js';
 import { pluralize } from '../../utils/pluralize.js';
+import { CHILD_THEME_SUFFIX } from '../../utils/theme-styles-format.js';
 const BATCH_SIZE = 100;
 // Code goes up, content comes down: the content of <from> replaces the local site's, IDs
 // unchanged, never the reverse and never into the repo. Not a `pull`: nothing is written to
@@ -22,7 +26,7 @@ export default class Copy extends LoopressCommand {
     static baseFlags = {
         env: Flags.string({ hidden: true }),
     };
-    static description = 'Replace the local site\'s content (posts, pages, public custom post types, terms) with the content of <from>, then push the project to the local site so tracked configuration wins. Media stay served by <from>, users, comments and orders are never copied.';
+    static description = 'Replace the local site\'s content (posts, pages, public custom post types, terms) with the content of <from>, activate the theme and plugins active there (when installed locally), then push the project to the local site so tracked configuration wins. Media stay served by <from>, users, comments and orders are never copied.';
     static enableJsonFlag = true;
     static examples = ['$ lps content copy production', '$ lps content copy staging --dry-run'];
     static flags = {
@@ -41,6 +45,8 @@ export default class Copy extends LoopressCommand {
         const source = this.sourceWp(from);
         if (!this.dryRun)
             await this.confirmReplace(from);
+        // Read before the reset: a failing read must not leave the local site emptied and unpushed.
+        const alignment = await this.readAlignment(source, from);
         const info = await source.get('loopress/v1/content');
         if (!this.dryRun) {
             await this.wp.post('loopress/v1/content/reset', { home: info.home, uploadsUrl: info.uploadsUrl });
@@ -49,6 +55,10 @@ export default class Copy extends LoopressCommand {
         const terms = await this.copy('terms', source);
         this.log(`→ Copying posts from ${from}...`);
         const posts = await this.copy('posts', source);
+        // Before the push: it must meet the source's plugins (a snippet push needs its plugin active)
+        // and its theme (templates and Global Styles go to the active one).
+        await this.alignPlugins(alignment, from);
+        const pendingChild = await this.alignTheme(alignment, from);
         const summary = `${pluralize(posts, 'post')} and ${pluralize(terms, 'term')}`;
         if (this.dryRun) {
             this.log(`\n[dry-run] Would replace the local content with ${summary} from ${from}, then push the project to ${LOCAL_ENVIRONMENT_NAME}.`);
@@ -56,6 +66,9 @@ export default class Copy extends LoopressCommand {
         }
         this.log(`\n→ Pushing the project to ${LOCAL_ENVIRONMENT_NAME}...`);
         await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', ['--env', LOCAL_ENVIRONMENT_NAME, '--yes']));
+        // The push may have activated it already, through the project's activateChildTheme.
+        if (pendingChild && (await activateTheme(this.wp, pendingChild)).changed)
+            this.log(`Activated ${pendingChild}, like on ${from}.`);
         this.log(`\nCopied ${summary} from ${from}.`);
         return { from, posts, status: 'copied', terms };
     }
@@ -70,6 +83,54 @@ export default class Copy extends LoopressCommand {
             this.error(`No credentials configured for ${env.url}. Run \`lps project config\` to add them.`);
         return new WpClient(env.url, env.token, env.name);
     }
+    // Activates locally the plugins active on <from> but inactive here. Never installs: a plugin
+    // missing here is reported, composer.json is where it gets declared.
+    async alignPlugins({ localPlugins, sourcePlugins }, from) {
+        const local = new Map(localPlugins.map((plugin) => [plugin.slug, plugin]));
+        const activeThere = sourcePlugins.filter((plugin) => plugin.active);
+        const missing = activeThere.filter((plugin) => !local.has(plugin.slug)).map((plugin) => plugin.slug);
+        if (missing.length > 0)
+            this.warn(`Active on ${from} but not installed locally: ${missing.join(', ')}. Declare them in composer.json.`);
+        const toActivate = activeThere.flatMap((plugin) => {
+            const here = local.get(plugin.slug);
+            return here && !here.active ? [here] : [];
+        });
+        for (const plugin of toActivate) {
+            if (this.dryRun) {
+                this.log(`[dry-run] Would activate ${plugin.slug}, active on ${from}.`);
+                continue;
+            }
+            await this.wp.put(`wp/v2/plugins/${plugin.file}`, { status: 'active' });
+            this.log(`Activated ${plugin.slug}, like on ${from}.`);
+        }
+    }
+    // Activates locally the theme active on <from>. When that is the Loopress child, not written
+    // here yet, its parent is activated now and the child returned, to activate once the push has
+    // written it.
+    async alignTheme({ here, installedThemes: installed, there }, from) {
+        if (here.active === there.active)
+            return undefined;
+        const isChild = there.active === `${there.template}${CHILD_THEME_SUFFIX}`;
+        let now;
+        if (installed.has(there.active))
+            now = there.active;
+        else if (isChild && installed.has(there.template))
+            now = there.template;
+        if (!now) {
+            this.warn(`${there.active} is active on ${from} but not installed locally, the local site keeps ${here.active}.`);
+            return undefined;
+        }
+        const later = now === there.active ? undefined : there.active;
+        if (this.dryRun) {
+            this.log(`[dry-run] Would activate ${later ?? now} instead of ${here.active}, like on ${from}.`);
+            return undefined;
+        }
+        if (now !== here.active) {
+            await activateTheme(this.wp, now);
+            this.log(`Activated ${now}, like on ${from}.`);
+        }
+        return later;
+    }
     async confirmReplace(from) {
         if (this.yes)
             return;
@@ -87,11 +148,27 @@ export default class Copy extends LoopressCommand {
         while (after !== null) {
             const page = await source.get(`loopress/v1/content/${kind}?after=${after}&limit=${BATCH_SIZE}`);
             const { next, ...rows } = page;
-            count += rows[kind].length;
+            const batch = rows[kind];
+            // The local site is already emptied: a page without its list must stop the copy, not count as 0.
+            if (!Array.isArray(batch))
+                this.error(`${kind} page after ${after} from the source has no "${kind}" list.`);
+            count += batch.length;
             if (!this.dryRun)
                 await this.wp.post(`loopress/v1/content/${kind}`, rows);
             after = next;
         }
         return count;
     }
+    // Everything alignPlugins and alignTheme read. The local theme list only matters when the
+    // active themes differ.
+    async readAlignment(source, from) {
+        const [sourcePlugins, localPlugins, { theme: there }, { theme: here }] = await Promise.all([
+            source.get('wp/v2/plugins').then(parseInstalledPlugins),
+            this.wp.get('wp/v2/plugins').then(parseInstalledPlugins),
+            getCapabilities(source, from),
+            this.capabilities(),
+        ]);
+        const installedThemes = here.active === there.active ? new Set() : new Set((await this.wp.get('wp/v2/themes')).map((theme) => theme.stylesheet));
+        return { here, installedThemes, localPlugins, sourcePlugins, there };
+    }
 }

package/dist/commands/dev.d.ts

@@ -3,8 +3,8 @@ export default class Dev extends Command {
     static description: string;
     static examples: string[];
     static flags: {
-        only: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        skip: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        only: ReturnType<typeof import("@oclif/core/flags").string>;
+        skip: ReturnType<typeof import("@oclif/core/flags").string>;
     };
     run(): Promise<void>;
     private parseTypeFlag;

package/dist/commands/dev.js

@@ -1,23 +1,27 @@
-import { Command, Flags } from '@oclif/core';
+import { Command } from '@oclif/core';
 import { watch as watchFiles } from 'chokidar';
 import { basename } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { buildWatchTargets, createDebouncedBatcher, resolveResourceTypes, RESOURCE_TYPES, resourceTypeForPath } from '../lib/dev-watch.js';
+import { disableExclusions } from '../lib/exclude.js';
+import { errorMessage, isOneOf } from '../lib/narrow.js';
+import { parseSelectionFlag, selectionFlags } from '../lib/resource-selection.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 const DEBOUNCE_MS = 400;
 // Noise no one wants pushed: VCS internals, deps, and editor/OS droppings.
-const IGNORED = /(?:(^|[/\\])(\.git|node_modules|\.DS_Store)(?:[/\\]|$))|(?:\.swp$)/;
+const IGNORED = /(?:^|[/\\])(?:(?:\.git|node_modules|\.DS_Store)(?:[/\\]|$)|[^/\\]*\.swp$)/;
 export default class Dev extends Command {
     static description = 'Watch project files and push changes to the local WordPress instance as they happen. Always targets the "local" environment, run `lps snippet push` etc. directly for any other environment.';
-    static examples = ['$ lps dev', '$ lps dev --only=snippets,api', '$ lps dev --skip=plugins'];
+    static examples = ['$ lps dev', '$ lps dev --only=snippet,api', '$ lps dev --skip=plugin'];
     static flags = {
-        only: Flags.string({ description: `Only watch these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),
-        skip: Flags.string({ description: `Skip these resource types (comma-separated): ${RESOURCE_TYPES.join(', ')}` }),
+        ...selectionFlags('watch', RESOURCE_TYPES),
     };
     async run() {
         const { flags } = await this.parse(Dev);
-        const only = flags.only ? this.parseTypeFlag(flags.only, 'only') : undefined;
-        const skip = flags.skip ? this.parseTypeFlag(flags.skip, 'skip') : [];
+        // Dev only targets local, where an excluded feature is being built: it pushes everything.
+        disableExclusions();
+        const only = this.parseTypeFlag(flags.only, 'only');
+        const skip = this.parseTypeFlag(flags.skip, 'skip');
         const types = resolveResourceTypes(only, skip);
         const localConfig = await readLocalConfig();
         const projectId = localConfig.projectId ?? configManager.getCurrentProject()?.id;
@@ -35,16 +39,7 @@ export default class Dev extends Command {
         await this.watch(targets);
     }
     parseTypeFlag(raw, flagName) {
-        return raw
-            .split(',')
-            .map((value) => value.trim())
-            .filter(Boolean)
-            .map((value) => {
-            if (!RESOURCE_TYPES.includes(value)) {
-                this.error(`Unknown resource type "${value}" in --${flagName}. Valid types: ${RESOURCE_TYPES.join(', ')}`);
-            }
-            return value;
-        });
+        return parseSelectionFlag(raw, flagName, RESOURCE_TYPES, (message) => this.error(message)).filter((value) => isOneOf(RESOURCE_TYPES, value));
     }
     // Sequential on purpose (see notes technique: parallelizing push is out of scope). A failed
     // push is logged and swallowed here, never thrown, so one bad batch can't take the watcher down.
@@ -69,7 +64,7 @@ export default class Dev extends Command {
                 this.log(`✓ ${label} synced`);
             }
             catch (error) {
-                this.log(`✗ ${label} failed: ${error.message}`);
+                this.log(`✗ ${label} failed: ${errorMessage(error)}`);
             }
         }
     }

package/dist/commands/diff.d.ts

@@ -4,11 +4,14 @@ export default class Diff extends DiffCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
-        only: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        skip: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        only: ReturnType<typeof import("@oclif/core/flags").string>;
+        skip: ReturnType<typeof import("@oclif/core/flags").string>;
+        'skip-unsupported': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<DiffJson>;
+    private composerSiteTarget;
     private projectUses;
-    private selectResources;
+    private siteMissing;
+    private withSiteSkip;
 }

package/dist/commands/diff.js

@@ -1,6 +1,11 @@
-import { Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getCapabilities, integrationFix, missingIntegration, missingModule } from '../lib/capabilities.js';
+import { declaredPlugins } from '../lib/declared-plugins.js';
 import { DiffCommand } from '../lib/diff-command.js';
+import { parseSelectionFlag, selectionFlags, selectResources } from '../lib/resource-selection.js';
 import { RESOURCE_STATE_PROVIDERS } from '../lib/resource-state.js';
+import {} from '../lib/wp-client.js';
 import { projectUses, resolveResourceDir } from '../utils/resource-dirs.js';
 import { globalStylesFiles } from '../utils/theme-styles-format.js';
 // Everything `lps diff` can compare, in report order. Composer isn't a directory-backed
@@ -9,7 +14,7 @@ const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resour
 export default class Diff extends DiffCommand {
     static description = [
         'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
-        'Covers snippets, forms, ACF, API routes, hooks, templates, template parts, pages, menus, custom post types, taxonomies, post meta, roles, block patterns, options, theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Covers snippets, forms, ACF, API routes, hooks, dynamic blocks, templates, template parts, pages, menus, custom post types, taxonomies, post meta, roles, block patterns, options, theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
         'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
     ].join(' ');
     static enableJsonFlag = true;
@@ -22,19 +27,39 @@ export default class Diff extends DiffCommand {
     ];
     static flags = {
         ...DiffCommand.againstFlag,
-        only: Flags.string({ description: 'Only compare these resources', multiple: true, options: [...RESOURCES] }),
-        skip: Flags.string({ description: 'Compare every resource except these', multiple: true, options: [...RESOURCES] }),
+        ...DiffCommand.skipUnsupportedFlag,
+        ...selectionFlags('compare', RESOURCES),
     };
     async run() {
         const { flags } = await this.parse(Diff);
         const sides = this.resolveSides(flags.against);
-        const selected = this.selectResources(flags.only, flags.skip);
+        const selected = new Set(selectResources(RESOURCES, parseSelectionFlag(flags.only, 'only', RESOURCES, (message) => this.error(message)), parseSelectionFlag(flags.skip, 'skip', RESOURCES, (message) => this.error(message))));
         const providers = RESOURCE_STATE_PROVIDERS.filter((provider) => selected.has(provider.resource));
+        const skipUnsupported = flags['skip-unsupported'];
         const targets = [
-            ...(await Promise.all(providers.map(async (provider) => ({ ...this.providerTarget(provider, sides), optional: !(await this.projectUses(provider)) })))),
-            ...(selected.has('composer') ? [this.composerTarget(sides)] : []),
+            ...(await Promise.all(providers.map(async (provider) => {
+                const lacking = await this.siteMissing((capabilities) => missingIntegration(provider.dirKind, capabilities), sides);
+                return this.withSiteSkip(this.providerTarget(provider, sides), lacking, await this.projectUses(provider), skipUnsupported);
+            }))),
+            ...(selected.has('composer') ? [await this.composerSiteTarget(sides, skipUnsupported)] : []),
         ];
-        return this.report(targets, sides);
+        if (skipUnsupported) {
+            const declared = await declaredPlugins({ localConfig: this.localConfig, rootDir: this.rootDir, siteName: this.siteConfig.name });
+            for (const { unsupported } of targets) {
+                if (unsupported)
+                    unsupported.fix = integrationFix(unsupported.missing, declared);
+            }
+        }
+        const result = await this.report(targets, sides);
+        // Only the environment against its local files is drift; two environments differing is not.
+        if (!sides.againstWp)
+            await this.reportDrift(result);
+        return result;
+    }
+    async composerSiteTarget(sides, skipUnsupported) {
+        const lacking = await this.siteMissing((capabilities) => missingModule('dependencies', 'Composer files', capabilities), sides);
+        const used = existsSync(resolve(process.cwd(), this.rootDir, 'composer.json'));
+        return this.withSiteSkip(this.composerTarget(sides), lacking, used, skipUnsupported);
     }
     // Tells apart a resource the project doesn't use from one it does, for the ones a site can lack:
     // a plugin-backed resource without its directory, Global Styles without a tracked file.
@@ -44,10 +69,35 @@ export default class Diff extends DiffCommand {
         }
         return projectUses(provider.dirKind, this.localConfig);
     }
-    // `--only` narrows the default set, `--skip` then removes from whatever that set is, same
-    // precedence a combined `--only=a,b --skip=b` reads as (mirrors dev-watch's resolveResourceTypes).
-    selectResources(only, skip) {
-        const base = only && only.length > 0 ? only : RESOURCES;
-        return new Set(base.filter((resource) => !(skip ?? []).includes(resource)));
+    // Either side can't hold the resource. Capabilities that can't be read (site down, plugin too
+    // old) skip nothing: the comparison then reports the failure itself, as inconclusive.
+    async siteMissing(missing, sides) {
+        try {
+            // Inside the try: `this.wp` errors out without credentials, the comparison reports that.
+            const sites = [[this.wp, sides.leftLabel]];
+            if (sides.againstWp)
+                sites.push([sides.againstWp, sides.rightLabel]);
+            const all = await Promise.all(sites.map(async ([wp, site]) => ({ capabilities: await getCapabilities(wp, site), site })));
+            for (const { capabilities, site } of all) {
+                const found = missing(capabilities);
+                if (found)
+                    return { missing: found, site };
+            }
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // A resource the site can't hold is skipped when the project doesn't use it, and also when it
+    // does with --skip-unsupported, which then reports why instead of "not configured".
+    withSiteSkip(target, lacking, used, skipUnsupported) {
+        if (!lacking)
+            return target;
+        if (!used)
+            return { ...target, skip: true };
+        if (!skipUnsupported)
+            return target;
+        return { ...target, skip: true, unsupported: { missing: lacking.missing, reason: `${lacking.missing.reason} on ${lacking.site}` } };
     }
 }

package/dist/commands/doctor.d.ts

@@ -1,14 +1,16 @@
 import { LoopressCommand } from '../lib/base.js';
+import { type SiteCapabilities } from '../lib/capabilities.js';
 export type DoctorCheck = {
     message?: string;
     ok: boolean;
     title: string;
 };
 export type DoctorResult = {
+    capabilities?: SiteCapabilities | undefined;
     checks: DoctorCheck[];
     environment: string;
     ok: boolean;
-    pluginVersion?: string;
+    pluginVersion?: string | undefined;
     project: string;
     url: string;
 };
@@ -19,8 +21,8 @@ export default class Doctor extends LoopressCommand {
     private readonly checks;
     run(): Promise<DoctorResult>;
     private check;
+    private checkCapabilities;
     private checkHookErrors;
     private checkLeftoverTempAdmins;
     private out;
-    private reportPluginVersion;
 }

package/dist/commands/doctor.js

@@ -1,8 +1,10 @@
 import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
+import {} from '../lib/capabilities.js';
+import { errorMessage } from '../lib/narrow.js';
 import { formatRuntimeError, HOOK_FILES_RESOURCE } from '../lib/php-files-command.js';
 import { findTempAdmins } from '../lib/temp-admin.js';
-import { isForbiddenError, isNotFoundError } from '../lib/wp-client.js';
+import { isApplicationPasswordsDisabled, isForbiddenError, isNotFoundError } from '../lib/wp-client.js';
 import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
 import { pluralize } from '../utils/pluralize.js';
 export default class Doctor extends LoopressCommand {
@@ -20,7 +22,7 @@ export default class Doctor extends LoopressCommand {
         this.out(`Environment:  ${name}`);
         this.out(`URL:          ${url}`);
         this.out('');
-        let pluginVersion;
+        let capabilities;
         const isReachable = await this.check('WordPress REST API reachable', async () => {
             const diagnostic = await diagnoseWpSite(url);
             if (!diagnostic.ok)
@@ -31,16 +33,28 @@ export default class Doctor extends LoopressCommand {
                 // The namespace index answers regardless of which Loopress features are active, so a
                 // 404 here can only mean the plugin itself is missing or outdated (WpClient's 404
                 // message already says exactly that).
-                await this.check('Loopress plugin installed (loopress/v1 endpoints)', async () => this.wp.get('loopress/v1'));
+                const isInstalled = await this.check('Loopress plugin installed (loopress/v1 endpoints)', async () => this.wp.get('loopress/v1'));
                 // wp/v2/users/me is WordPress core and requires authentication, so it validates the
                 // application password without depending on any Loopress feature.
-                const isAuthenticated = await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me'));
+                const isAuthenticated = await this.check('Credentials accepted (authenticated request)', async () => {
+                    try {
+                        await this.wp.get('wp/v2/users/me');
+                    }
+                    catch (error) {
+                        if (isApplicationPasswordsDisabled(error)) {
+                            throw new Error('Application Passwords are disabled for this account. Enable them for this user (a security plugin or the `wp_is_application_passwords_available` filter may turn them off), or use another account.', { cause: error });
+                        }
+                        throw error;
+                    }
+                });
                 // Skipped when the credentials were just rejected: it would only repeat that same 401.
                 if (isAuthenticated) {
+                    // Without the plugin it would only repeat that same 404.
+                    if (isInstalled)
+                        capabilities = await this.checkCapabilities();
                     await this.checkLeftoverTempAdmins();
                     await this.checkHookErrors();
                 }
-                pluginVersion = await this.reportPluginVersion();
             }
             else {
                 this.checks.push({
@@ -62,7 +76,7 @@ export default class Doctor extends LoopressCommand {
         this.out(ok ? 'All checks passed.' : `${pluralize(failed, 'check')} failed.`);
         if (!ok)
             process.exitCode = 1;
-        return { checks: this.checks, environment: name, ok, pluginVersion, project: projectName, url };
+        return { capabilities, checks: this.checks, environment: name, ok, pluginVersion: capabilities?.version, project: projectName, url };
     }
     async check(title, run) {
         try {
@@ -72,13 +86,41 @@ export default class Doctor extends LoopressCommand {
             return true;
         }
         catch (error) {
-            const { message } = error;
+            const message = errorMessage(error);
             this.checks.push({ message, ok: false, title });
             this.out(`✗ ${title}`);
             this.out(`  ${message}`);
             return false;
         }
     }
+    // The CLI decides what to run from these, so an older plugin without them fails the doctor.
+    // The rest is informational.
+    async checkCapabilities() {
+        let capabilities;
+        await this.check('Plugin recent enough for this CLI (loopress/v1/capabilities)', async () => {
+            capabilities = await this.capabilities();
+        });
+        if (!capabilities)
+            return undefined;
+        const { edition, environmentType, integrations, theme, version } = capabilities;
+        const state = (active) => {
+            if (active === undefined)
+                return 'needs Loopress Full';
+            return active ? 'active' : 'none';
+        };
+        this.out(`- Plugin: Loopress ${edition === 'full' ? 'Full' : 'Light'} ${version}, environment type "${environmentType}"`);
+        this.out(`- Integrations: ACF ${state(integrations.acf)}, forms ${state(integrations.form)}, snippets ${state(integrations.snippets)}`);
+        this.out(`- Theme: ${theme.active} (${theme.isBlock ? 'block theme' : 'classic theme'})`);
+        if (theme.child) {
+            let childState = 'not pushed yet';
+            if (theme.child.active)
+                childState = 'active';
+            else if (theme.child.exists)
+                childState = 'not active, `lps theme activate`';
+            this.out(`- Loopress child theme: ${theme.child.stylesheet}, ${childState}`);
+        }
+        return capabilities;
+    }
     // A hook that fails to load or throws while running doesn't break the site, it just quietly
     // does nothing, and its only trace is an error_log nobody reads on managed hosting.
     async checkHookErrors() {
@@ -131,22 +173,4 @@ export default class Doctor extends LoopressCommand {
         if (!this.jsonEnabled())
             this.log(message);
     }
-    // Informational only: Loopress Light does not expose loopress/v1/update, and an old plugin
-    // predates it, neither should flip the doctor to a failure when everything else works.
-    async reportPluginVersion() {
-        try {
-            const status = await this.wp.get('loopress/v1/update');
-            const version = status.current_version ?? '(unknown)';
-            this.out(`✓ Plugin version: ${version}`);
-            return version;
-        }
-        catch (error) {
-            if (isNotFoundError(error)) {
-                this.out('- Plugin version: not exposed by this plugin edition.');
-                return undefined;
-            }
-            this.out(`- Plugin version: could not be read. ${error.message}`);
-            return undefined;
-        }
-    }
 }

package/dist/commands/form/pull.js

@@ -24,11 +24,14 @@ export default class Pull extends LoopressCommand {
         this.log(`Pulling forms from ${url}`);
         this.log(`Forms path: ${path}`);
         const remoteList = await this.wp.get(FORM_ENDPOINT);
-        const withId = remoteList.filter((form) => getFormId(form) !== null);
+        const withId = remoteList.flatMap((form) => {
+            const id = getFormId(form);
+            return id === null ? [] : [{ form, id }];
+        });
         const skipped = remoteList.length - withId.length;
         // Only matches files following the `<id>-<slug>.json` convention pull/push themselves
         // produce, same principle as `snippet pull`.
-        const orphans = await findOrphanedFiles(path, new Set(withId.map((form) => String(getFormId(form)))), {
+        const orphans = await findOrphanedFiles(path, new Set(withId.map(({ id }) => String(id))), {
             extensions: ['.json'],
             key: numericPrefixKey,
         });
@@ -36,9 +39,8 @@ export default class Pull extends LoopressCommand {
             dryRunMessage: `Would pull ${pluralize(withId.length, 'form')} to ${path}`,
             orphanReason: `in ${path} no longer present on WordPress`,
             pulledMessage: `Pulled ${pluralize(withId.length, 'form')} to ${path}`,
-            title: (form) => getFormTitle(form),
-            async write(form, writeDir) {
-                const id = getFormId(form);
+            title: ({ form }) => getFormTitle(form),
+            async write({ form, id }, writeDir) {
                 const title = getFormTitle(form);
                 // `revision` is server bookkeeping (see RemoteForm in form-format.ts), never part of
                 // the tracked configuration: never persisted locally.

package/dist/commands/form/push.js

@@ -1,6 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
+import { errorMessage, isRecord } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
 import { readdirTolerant } from '../../lib/readdir-tolerant.js';
@@ -82,10 +83,10 @@ export default class Push extends PushCommand {
                 parsed = JSON.parse(await readFile(filePath, 'utf8'));
             }
             catch (error) {
-                this.warn(`Skipping "${filePath}": ${error.message}`);
+                this.warn(`Skipping "${filePath}": ${errorMessage(error)}`);
                 continue;
             }
-            if (typeof parsed !== 'object' || parsed === null) {
+            if (!isRecord(parsed)) {
                 this.warn(`Skipping "${filePath}": not a JSON object`);
                 continue;
             }
@@ -129,7 +130,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${title}`;
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${title}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${title}: ${errorMessage(error)}`, error, task);
         }
     }
 }

package/dist/commands/init.js

@@ -66,8 +66,9 @@ export default class Init extends Command {
                 this.log('Still no project configured, falling back to manual entry.');
                 return this.promptManualProjectId();
             }
-            if (projects.length === 1) {
-                return { projectId: projects[0].id, projectLabel: projects[0].name };
+            const [only] = projects;
+            if (only && projects.length === 1) {
+                return { projectId: only.id, projectLabel: only.name };
             }
         }
         const choice = await select({
@@ -77,6 +78,6 @@ export default class Init extends Command {
         if (choice === '__manual__') {
             return this.promptManualProjectId();
         }
-        return { projectId: choice, projectLabel: projects.find((p) => p.id === choice).name };
+        return { projectId: choice, projectLabel: projects.find((p) => p.id === choice)?.name ?? choice };
     }
 }

package/dist/commands/menu/push.js

@@ -1,11 +1,12 @@
 import { Args } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
+import { errorCode, errorMessage, isRecord } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { readdirTolerant } from '../../lib/readdir-tolerant.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
-import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT, menuEndpoint } from '../../utils/menu-format.js';
+import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS, MENU_LOCATIONS_ENDPOINT, menuEndpoint } from '../../utils/menu-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 // A menu literally slugged "menu-locations" would still collide, but that's far less likely
 // than the plain "locations" this used to be (WordPress's own menu-locations feature).
@@ -59,7 +60,7 @@ export default class Push extends PushCommand {
             raw = await readFile(file, 'utf8');
         }
         catch (error) {
-            if (error.code === 'ENOENT')
+            if (errorCode(error) === 'ENOENT')
                 return;
             throw error;
         }
@@ -68,12 +69,12 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            await this.wp.put(MENU_LOCATIONS_ENDPOINT, JSON.parse(raw));
+            await this.wp.put(MENU_LOCATIONS_ENDPOINT, MENU_LOCATIONS.parse(JSON.parse(raw)));
             this.log(`Pushed: ${file}`);
         }
         catch (error) {
             this.failedCount++;
-            this.warn(`Failed to push ${file}: ${error.message}`);
+            this.warn(`Failed to push ${file}: ${errorMessage(error)}`);
         }
     }
     async pushMenuFile(filePath, task) {
@@ -83,10 +84,9 @@ export default class Push extends PushCommand {
             return;
         }
         try {
-            const parsed = JSON.parse(await readFile(filePath, 'utf8'));
-            if (typeof parsed !== 'object' || parsed === null)
+            const record = JSON.parse(await readFile(filePath, 'utf8'));
+            if (!isRecord(record))
                 throw new Error('not a JSON object');
-            const record = parsed;
             const slug = getMenuSlug(record);
             if (slug === null)
                 throw new Error('missing or invalid "slug"');
@@ -109,7 +109,7 @@ export default class Push extends PushCommand {
             }
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${filePath}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${filePath}: ${errorMessage(error)}`, error, task);
         }
     }
     async pushMenus(basePath) {