@loopress/cli 0.32.1 → 0.33.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.js

@@ -3,10 +3,11 @@ 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 { errorMessage, isOneOf } from '../lib/narrow.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'];
@@ -40,7 +41,7 @@ export default class Dev extends Command {
             .map((value) => value.trim())
             .filter(Boolean)
             .map((value) => {
-            if (!RESOURCE_TYPES.includes(value)) {
+            if (!isOneOf(RESOURCE_TYPES, value)) {
                 this.error(`Unknown resource type "${value}" in --${flagName}. Valid types: ${RESOURCE_TYPES.join(', ')}`);
             }
             return value;
@@ -69,7 +70,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

@@ -11,4 +11,5 @@ export default class Diff extends DiffCommand {
     run(): Promise<DiffJson>;
     private projectUses;
     private selectResources;
+    private siteLacks;
 }

package/dist/commands/diff.js

@@ -1,6 +1,10 @@
 import { Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getCapabilities, missingIntegration, missingModule } from '../lib/capabilities.js';
 import { DiffCommand } from '../lib/diff-command.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 +13,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;
@@ -31,8 +35,19 @@ export default class Diff extends DiffCommand {
         const selected = this.selectResources(flags.only, flags.skip);
         const providers = RESOURCE_STATE_PROVIDERS.filter((provider) => selected.has(provider.resource));
         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) => ({
+                ...this.providerTarget(provider, sides),
+                skip: !(await this.projectUses(provider)) && (await this.siteLacks((capabilities) => missingIntegration(provider.dirKind, capabilities), sides)),
+            })))),
+            ...(selected.has('composer')
+                ? [
+                    {
+                        ...this.composerTarget(sides),
+                        skip: !existsSync(resolve(process.cwd(), this.rootDir, 'composer.json')) &&
+                            (await this.siteLacks((capabilities) => missingModule('dependencies', 'Composer files', capabilities), sides)),
+                    },
+                ]
+                : []),
         ];
         return this.report(targets, sides);
     }
@@ -50,4 +65,19 @@ export default class Diff extends DiffCommand {
         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 siteLacks(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, name]) => getCapabilities(wp, name)));
+            return all.some((capabilities) => missing(capabilities) !== undefined);
+        }
+        catch {
+            return false;
+        }
+    }
 }

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,5 +1,7 @@
 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';
@@ -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,18 @@ 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'));
                 // 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 +66,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 +76,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 +163,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) {

package/dist/commands/option/list.js

@@ -79,11 +79,14 @@ const NON_TTY_FALLBACK_COLUMNS = 300;
 // column. See confidenceColor() above for SOURCE?/PLUGIN's shared sûr/pas sûr color coding.
 function renderTable(rows, { includeCore }) {
     const previousColumns = process.env.COLUMNS;
-    if (!process.stdout.columns)
+    // Undefined on a non-TTY stdout, despite its `number` type.
+    const ttyColumns = process.stdout.columns > 0 ? process.stdout.columns : undefined;
+    if (!previousColumns && ttyColumns === undefined)
         process.env.COLUMNS = String(NON_TTY_FALLBACK_COLUMNS);
     // Mirrors tty-table's own getAvailableWidth(): its column-width percentages are computed against
     // this same number, so fillPercent() above needs it too to reserve the right amount for AUTOLOAD/CORE.
-    const width = (process.stdout.columns || Number(process.env.COLUMNS) || NON_TTY_FALLBACK_COLUMNS) - 2;
+    const envColumns = Number(process.env.COLUMNS);
+    const width = (ttyColumns ?? (envColumns > 0 ? envColumns : NON_TTY_FALLBACK_COLUMNS)) - 2;
     const header = [
         { align: 'left', headerAlign: 'left', value: 'NAME', width: columnWidth(COLUMN_WEIGHT.name, width, includeCore) },
         { align: 'left', headerAlign: 'left', value: 'AUTOLOAD' },

package/dist/commands/option/push.js

@@ -1,5 +1,6 @@
 import { Args } from '@oclif/core';
 import { loadFiles } from '../../lib/load-files.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
@@ -89,7 +90,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${option.name}`;
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${option.name}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${option.name}: ${errorMessage(error)}`, error, task);
         }
     }
 }

package/dist/commands/option/{remove.d.ts → rm.d.ts}

@@ -5,6 +5,7 @@ type RemoveResult = {
     status: 'aborted' | 'dry-run' | 'success';
 };
 export default class Remove extends LoopressCommand {
+    static aliases: string[];
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };

package/dist/commands/option/{remove.js → rm.js}

@@ -8,13 +8,14 @@ import { isInteractive } from '../../lib/interactive.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { optionEndpoint, optionFileName } from '../../utils/option-format.js';
 export default class Remove extends LoopressCommand {
+    static aliases = ['option:remove'];
     static args = {
         name: Args.string({ description: 'Option name to stop tracking', required: true }),
     };
     static description = 'Stop tracking an option locally and delete it from WordPress. Local untracking always happens (git-reversible); ' +
         'pass --local-only to skip the WordPress delete and only stop tracking.';
     static enableJsonFlag = true;
-    static examples = ['$ lps option remove wpseo_titles', '$ lps option remove wpseo_titles --local-only'];
+    static examples = ['$ lps option rm wpseo_titles', '$ lps option rm wpseo_titles --local-only'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,

package/dist/commands/page/push.js

@@ -1,6 +1,7 @@
 import { confirm } from '@inquirer/prompts';
 import { Args } from '@oclif/core';
 import { isInteractive } from '../../lib/interactive.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isConflictCode } from '../../lib/wp-client.js';
@@ -90,7 +91,7 @@ export default class Push extends PushCommand {
                 task?.skip?.(`${page.slug} already exists on the site, not created by Loopress`);
                 return false;
             }
-            this.reportTaskFailure(`Failed to push ${page.slug}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${page.slug}: ${errorMessage(error)}`, error, task);
         }
     }
 }

package/dist/commands/plugin/audit.d.ts

@@ -1,9 +1,9 @@
 import { LoopressCommand } from '../../lib/base.js';
 type Advisory = {
-    cve?: string;
-    fixedIn?: string;
-    score?: number;
-    severity?: string;
+    cve?: string | undefined;
+    fixedIn?: string | undefined;
+    score?: number | undefined;
+    severity?: string | undefined;
     slug: string;
     title: string;
 };