@loopress/cli 0.32.2 → 0.34.0

package/dist/commands/snippet/push.js

@@ -2,10 +2,13 @@ import { Args } from '@oclif/core';
 import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
+import { errorCode, errorMessage, isRecord } from '../../lib/narrow.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
+import {} from '../../types/snippet.generated.js';
+import {} from '../../types/snippet.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 import { toSlug } from '../../utils/to-slug.js';
@@ -65,18 +68,18 @@ export default class Push extends PushCommand {
         const currentBase = basename(snippet.path, ext);
         const canonicalBase = `${id}-${toSlug(name)}`;
         const oldMetaPath = join(dir, `${currentBase}.json`);
-        let meta = {};
+        let existing = {};
         try {
-            const existing = await readFile(oldMetaPath, 'utf8');
-            meta = JSON.parse(existing);
+            const parsed = JSON.parse(await readFile(oldMetaPath, 'utf8'));
+            if (isRecord(parsed))
+                existing = parsed;
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
+            if (errorCode(error) !== 'ENOENT')
                 throw error;
         }
-        meta.id = id;
-        meta.name = name;
-        meta.type = snippet.type;
+        // Spread, not rebuilt: keys the CLI doesn't know about survive, in their original order.
+        const meta = { ...existing, id, name, type: snippet.type };
         // Persist the id against the *current* file pairing before renaming anything, so a
         // crash between the rename and the sidecar write still leaves a valid `<name>.<ext>` /
         // `<name>.json` pair with the id on disk, and a retried `snippet push` won't re-create
@@ -95,7 +98,7 @@ export default class Push extends PushCommand {
             return await loadSnippetsFromDisk(path, (message) => { this.warn(message); });
         }
         catch (error) {
-            this.error(error.message);
+            this.error(errorMessage(error));
         }
     }
     async pushSnippet(snippet, task) {
@@ -134,15 +137,15 @@ export default class Push extends PushCommand {
                 id = createdSnippet.id;
                 await this.ensureCanonicalFilename(snippet, createdSnippet.id, createdSnippet.name);
             }
-            else {
-                await this.ensureCanonicalFilename(snippet, snippet.id, snippet.name);
+            else if (id !== undefined) {
+                await this.ensureCanonicalFilename(snippet, id, snippet.name);
             }
             if (task)
                 task.output = `Pushed: ${snippet.name}`;
             return id;
         }
         catch (error) {
-            this.reportTaskFailure(`Failed to push ${snippet.name}: ${error.message}`, error, task);
+            this.reportTaskFailure(`Failed to push ${snippet.name}: ${errorMessage(error)}`, error, task);
         }
     }
     toPayload(snippet) {
@@ -172,7 +175,7 @@ export default class Push extends PushCommand {
                 pathsById.set(id, [...(pathsById.get(id) ?? []), path]);
         }
         return snippets.filter((snippet) => {
-            const paths = snippet.id === undefined ? [] : pathsById.get(snippet.id);
+            const paths = snippet.id === undefined ? [] : (pathsById.get(snippet.id) ?? []);
             if (paths.length < 2)
                 return true;
             this.failedCount++;

package/dist/commands/status.js

@@ -1,5 +1,6 @@
 import { Command, Flags, ux } from '@oclif/core';
 import { configManager } from '../config/project-config.manager.js';
+import {} from '../types/config.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 const c = ux.colorize;
 export default class Status extends Command {

package/dist/commands/theme/activate.d.ts

@@ -0,0 +1,21 @@
+import { LoopressCommand } from '../../lib/base.js';
+type ActivateResult = {
+    active: string;
+    previous: string;
+    status: 'activated' | 'dry-run' | 'unchanged';
+};
+export default class Activate extends LoopressCommand {
+    static args: {
+        stylesheet: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<ActivateResult>;
+    private childStylesheet;
+}
+export {};

package/dist/commands/theme/activate.js

@@ -0,0 +1,44 @@
+import { Args } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { activateTheme } from '../../lib/capabilities.js';
+import { guardProductionPush } from '../../lib/guard-production-push.js';
+export default class Activate extends LoopressCommand {
+    static args = {
+        stylesheet: Args.string({ description: 'Theme to activate (default: the Loopress child theme, <parent>-loopress)' }),
+    };
+    static description = 'Activate a theme on WordPress, the Loopress child theme by default. A child theme without settings of its own starts from a copy of its parent\'s theme mods and Global Styles. Set "activateChildTheme": true in loopress.json to have `lps theme template push` keep the child active.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme activate', '$ lps theme activate twentytwentyfive --env staging', '$ lps theme activate --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Activate);
+        const { theme } = await this.capabilities();
+        const stylesheet = args.stylesheet ?? this.childStylesheet(theme);
+        if (stylesheet === theme.active) {
+            this.log(`${stylesheet} is already the active theme.`);
+            return { active: stylesheet, previous: theme.active, status: 'unchanged' };
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would activate ${stylesheet} instead of ${theme.active}.`);
+            return { active: stylesheet, previous: theme.active, status: 'dry-run' };
+        }
+        await guardProductionPush({ dryRun: this.dryRun, error: (message) => this.error(message), siteConfig: this.siteConfig, yes: this.yes });
+        const activation = await activateTheme(this.wp, stylesheet);
+        this.log(`Activated ${activation.active} (was ${activation.previous}).`);
+        return { active: activation.active, previous: activation.previous, status: 'activated' };
+    }
+    childStylesheet(theme) {
+        if (theme.child === undefined) {
+            this.error('The Loopress child theme needs Loopress Full. Name the theme to activate instead.');
+        }
+        else if (theme.child === null) {
+            this.error(`The active theme "${theme.active}" can't have a Loopress child theme: it needs a block theme that isn't already a child theme.`);
+        }
+        if (!theme.child.exists)
+            this.error(`${theme.child.stylesheet} doesn't exist yet. Run \`lps theme template push\` first.`);
+        return theme.child.stylesheet;
+    }
+}

package/dist/commands/theme/pull.js

@@ -1,5 +1,6 @@
 import { LoopressCommand } from '../../lib/base.js';
 import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { pluralize } from '../../utils/pluralize.js';
 // Templates and parts have no pull: the child theme is written from the project, never read back.
 const PULL_TARGETS = [
@@ -26,7 +27,7 @@ export default class Pull extends LoopressCommand {
                 results.push({ label: target.label, status: 'pulled' });
             }
             catch (error) {
-                const { message } = error;
+                const message = errorMessage(error);
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
             }

package/dist/commands/theme/push.js

@@ -4,7 +4,9 @@ import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
 import { guardProductionPush } from '../../lib/guard-production-push.js';
 import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { errorMessage } from '../../lib/narrow.js';
 import { pluralize } from '../../utils/pluralize.js';
+import { projectHasChildThemeFiles } from '../../utils/resource-dirs.js';
 // The parent theme must be installed before its child theme is written, and Global Styles
 // belong to whichever theme is active, so they go last.
 const PUSH_TARGETS = [
@@ -13,7 +15,7 @@ const PUSH_TARGETS = [
     { commandId: 'theme:style:push', label: 'Global Styles' },
 ];
 export default class Push extends LoopressCommand {
-    static description = 'Push everything theme related to WordPress: theme versions from loopress.json, then block templates and parts, then Global Styles. Never switches the active theme.';
+    static description = 'Push everything theme related to WordPress: theme versions from loopress.json, then block templates and parts, then Global Styles. Switches the active theme only to the Loopress child, when loopress.json sets "activateChildTheme": true.';
     static enableJsonFlag = true;
     static examples = ['$ lps theme push', '$ lps theme push --env staging', '$ lps theme push --dry-run'];
     static flags = {
@@ -34,7 +36,9 @@ export default class Push extends LoopressCommand {
         // Nothing to install and no composer.json: the versions step would only fail on an empty
         // manifest, which must not fail a templates or styles only project.
         const hasVersions = Object.keys(this.localConfig.themes ?? {}).length > 0 || existsSync(join(process.cwd(), this.rootDir, 'composer.json'));
-        const targets = hasVersions ? PUSH_TARGETS : PUSH_TARGETS.filter((target) => target.commandId !== 'theme:version:push');
+        // Same for templates: without templates, parts or CSS the step would refuse (nothing to push).
+        const hasChildTheme = projectHasChildThemeFiles(this.localConfig);
+        const targets = PUSH_TARGETS.filter((target) => (hasVersions || target.commandId !== 'theme:version:push') && (hasChildTheme || target.commandId !== 'theme:template:push'));
         const results = [];
         for (const target of targets) {
             const argv = ['--env', this.siteConfig.name, '--production-confirmed'];
@@ -51,7 +55,7 @@ export default class Push extends LoopressCommand {
                 results.push({ label: target.label, result, status: 'pushed' });
             }
             catch (error) {
-                const { message } = error;
+                const message = errorMessage(error);
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
             }

package/dist/commands/theme/style/diff.js

@@ -1,5 +1,5 @@
 import { resourceDiffCommand } from '../../../lib/diff-command.js';
-export default resourceDiffCommand('theme-styles', {
+export default resourceDiffCommand('theme-style', {
     description: "Show what differs in the active block theme's Global Styles (Site Editor > Styles) between your local file and a WordPress environment, or between two environments",
     command: 'theme style',
     pathNoun: 'theme styles directory',

package/dist/commands/theme/style/push.js

@@ -1,6 +1,7 @@
 import { Args } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { errorCode, isRecord } from '../../../lib/narrow.js';
 import { PushCommand } from '../../../lib/push-command.js';
 import { getResourceStateProvider } from '../../../lib/resource-state.js';
 import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../../utils/theme-styles-format.js';
@@ -27,18 +28,22 @@ export default class Push extends PushCommand {
             raw = await readFile(file, 'utf8');
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
+            if (errorCode(error) === 'ENOENT') {
                 this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme style pull\` first.`);
             }
             throw error;
         }
         // Only the active theme's file is pushed, whatever else the directory holds.
-        const provider = getResourceStateProvider('theme-styles');
+        const provider = getResourceStateProvider('theme-style');
         const beforeState = await this.captureBeforePushState(provider, dir, (name) => name === stylesheet);
         if (this.dryRun)
             return { changes: this.previewChanges, file, status: 'dry-run' };
         const local = JSON.parse(raw);
-        await this.wp.post(globalStylesEndpoint(id), { settings: local.settings ?? {}, styles: local.styles ?? {} });
+        // Never fall back to empty settings/styles: that push would wipe the site's customizations.
+        if (!isRecord(local))
+            throw new Error(`${file} is not a JSON object`);
+        const { settings, styles } = local;
+        await this.wp.post(globalStylesEndpoint(id), { settings: settings ?? {}, styles: styles ?? {} });
         this.log(`Pushed: ${file}`);
         await this.writeAfterPushSnapshot(provider, dir, beforeState);
         await this.recordSuccess();

package/dist/commands/theme/style/rollback.js

@@ -1,5 +1,5 @@
 import { resourceRollbackCommand } from '../../../lib/rollback-command.js';
-export default resourceRollbackCommand('theme-styles', {
+export default resourceRollbackCommand('theme-style', {
     description: "Restore the active theme's Global Styles to a snapshot taken automatically before an earlier `lps theme style push`",
     command: 'theme style',
     pathNoun: 'theme styles directory',

package/dist/commands/theme/template/push.d.ts

@@ -27,6 +27,8 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PushResult>;
+    private keptFromSite;
     private previewChildTheme;
+    private readChildTheme;
 }
 export {};

package/dist/commands/theme/template/push.js

@@ -1,12 +1,17 @@
 import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { activateTheme } from '../../../lib/capabilities.js';
+import {} from '../../../lib/diff-state.js';
+import { hasExclusions, isExcluded } from '../../../lib/exclude.js';
+import { errorMessage } from '../../../lib/narrow.js';
 import { logChanges, pushChanges, PushCommand } from '../../../lib/push-command.js';
 import { formatPageProblems } from '../../../utils/page-format.js';
 import { pluralize } from '../../../utils/pluralize.js';
-import { resolveResourceDir } from '../../../utils/resource-dirs.js';
+import { projectHasChildThemeFiles, resolveResourceDir } from '../../../utils/resource-dirs.js';
 import { CHILD_THEME_ENDPOINT, readLocalTemplates } from '../../../utils/template-format.js';
 import { bundleThemeCss } from '../../../utils/theme-css.js';
 export default class Push extends PushCommand {
-    static description = 'Push block templates (theme/templates/<slug>.html), template parts (theme/parts/<slug>.html) and the theme CSS (theme/css/style.css, theme/blocks/<namespace>/<block>.css, bundled with esbuild) as the files of a child theme of the active block theme, <parent>-loopress. The child mirrors the project: files removed locally are removed from it. It is never activated for you.';
+    static description = 'Push block templates (theme/templates/<slug>.html), template parts (theme/parts/<slug>.html) and the theme CSS (theme/css/style.css, theme/blocks/<namespace>/<block>.css, bundled with esbuild) as the files of a child theme of the active block theme, <parent>-loopress. The child mirrors the project: files removed locally are removed from it. It is activated only when loopress.json sets "activateChildTheme": true, see `lps theme activate`.';
     static enableJsonFlag = true;
     static examples = ['$ lps theme template push', '$ lps theme template push --dry-run'];
     static flags = {
@@ -17,6 +22,10 @@ export default class Push extends PushCommand {
         await this.parse(Push);
         const templatesPath = resolveResourceDir('template', this.localConfig);
         const partsPath = resolveResourceDir('part', this.localConfig);
+        // Pushing would only create an empty child theme as a side effect.
+        if (!projectHasChildThemeFiles(this.localConfig)) {
+            this.error(`Nothing to push: no ${templatesPath}, ${partsPath}, ${resolveResourceDir('css', this.localConfig)} or ${resolveResourceDir('blockCss', this.localConfig)} directory.`);
+        }
         this.log(`Pushing templates and parts to ${this.siteConfig.url}`);
         this.log(`Templates path: ${templatesPath}, parts path: ${partsPath}`);
         const { parts, problems, templates } = await readLocalTemplates(templatesPath, partsPath);
@@ -32,18 +41,37 @@ export default class Push extends PushCommand {
         };
         this.log(`Found ${pluralize(templates.length, 'template')}, ${pluralize(parts.length, 'part')}, ` +
             `${css.style ? 'a global stylesheet' : 'no global stylesheet'} and ${pluralize(css.blocks.length, 'block stylesheet')}`);
+        this.warnEnvironmentUrls([
+            ...templates.map((template) => ({ id: `templates/${template.slug}`, value: template.html })),
+            ...parts.map((part) => ({ id: `parts/${part.slug}`, value: part.html })),
+        ]);
+        // The PUT replaces every file of the child theme: what the site has under a path this
+        // environment excludes (loopress.json) is sent back as it is, so it is left alone.
+        const kept = await this.keptFromSite(templatesPath, partsPath, templates, parts);
         if (this.dryRun) {
-            const changes = await this.previewChildTheme(templates, parts, css);
+            const changes = await this.previewChildTheme(templates, parts, css, kept);
             logChanges((message) => { this.log(message); }, changes.templates, 'templates/');
             logChanges((message) => { this.log(message); }, changes.parts, 'parts/');
             logChanges((message) => { this.log(message); }, changes.css, 'css/');
+            if (this.localConfig.activateChildTheme) {
+                const { child } = (await this.capabilities()).theme;
+                if (child && !child.active)
+                    this.log(`[dry-run] Would activate ${child.stylesheet}.`);
+            }
             return { ...names, changes, status: 'dry-run' };
         }
-        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { ...css, parts, templates });
+        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { ...css, parts: [...parts, ...kept.parts], templates: [...templates, ...kept.templates] });
         await this.recordSuccess();
         this.log(`Child theme ${child.stylesheet} written.`);
-        if (!child.active) {
-            this.warn(`${child.stylesheet} is not the active theme, so nothing changed on the site yet. Activate it in Appearance > Themes.`);
+        // Activated only when the project asks for it: a theme switch changes every per-theme setting.
+        let { active } = child;
+        if (!active && this.localConfig.activateChildTheme) {
+            const activation = await activateTheme(this.wp, child.stylesheet);
+            active = true;
+            this.log(`Activated ${child.stylesheet} (was ${activation.previous}), as loopress.json's activateChildTheme asks.`);
+        }
+        if (!active) {
+            this.warn(`${child.stylesheet} is not the active theme, so nothing changed on the site yet. Run \`lps theme activate\`, or set "activateChildTheme": true in loopress.json.`);
         }
         if (child.customized.length > 0) {
             this.warn(`Edited in the Site Editor, their database copy still wins over the pushed file: ${child.customized.join(', ')}. ` +
@@ -57,22 +85,30 @@ export default class Push extends PushCommand {
         }
         return {
             ...names,
-            active: child.active,
+            active,
             customized: child.customized,
             status: 'success',
             stylesheet: child.stylesheet,
             unknownBlocks,
         };
     }
-    // Same read and same refusal as previewRemote, one GET for templates, parts and CSS.
-    async previewChildTheme(templates, parts, css) {
-        let child;
-        try {
-            child = await this.wp.get(CHILD_THEME_ENDPOINT);
-        }
-        catch (error) {
-            this.error(`The site would refuse this push: ${error.message}`);
-        }
+    // The site's templates and parts under an excluded path the project doesn't push. Refuses when
+    // the site can't be read: pushing blind would remove them.
+    async keptFromSite(templatesPath, partsPath, templates, parts) {
+        if (!hasExclusions())
+            return { parts: [], templates: [] };
+        const child = await this.readChildTheme();
+        const localTemplates = new Set(templates.map((template) => template.slug));
+        const localParts = new Set(parts.map((part) => part.slug));
+        return {
+            parts: child.parts.filter((part) => !localParts.has(part.slug) && isExcluded(join(partsPath, `${part.slug}.html`))),
+            templates: child.templates.filter((template) => !localTemplates.has(template.slug) && isExcluded(join(templatesPath, `${template.slug}.html`))),
+        };
+    }
+    // Same read and same refusal as previewRemote, one GET for templates, parts and CSS. Kept
+    // files are held back, they are neither changes nor removals.
+    async previewChildTheme(templates, parts, css, kept) {
+        const child = await this.readChildTheme();
         const localCss = new Map(css.blocks.map((block) => [`blocks/${block.name}.css`, sha256(block.css)]));
         if (css.style !== '')
             localCss.set('style.css', sha256(css.style));
@@ -81,14 +117,26 @@ export default class Push extends PushCommand {
             : [...localCss.keys()].toSorted((a, b) => a.localeCompare(b)).map((id) => ({ id, status: 'unknown' }));
         return {
             css: cssChanges,
-            parts: pushChanges(bySlug(parts), bySlug(child.parts), { mirror: true }),
-            templates: pushChanges(bySlug(templates), bySlug(child.templates), { mirror: true }),
+            parts: withoutKept(pushChanges(bySlug([...parts, ...kept.parts]), bySlug(child.parts), { mirror: true }), kept.parts),
+            templates: withoutKept(pushChanges(bySlug([...templates, ...kept.templates]), bySlug(child.templates), { mirror: true }), kept.templates),
         };
     }
+    async readChildTheme() {
+        try {
+            return await this.wp.get(CHILD_THEME_ENDPOINT);
+        }
+        catch (error) {
+            this.error(`The site would refuse this push: ${errorMessage(error)}`);
+        }
+    }
 }
 function bySlug(files) {
     return new Map(files.map(({ slug, ...rest }) => [slug, rest]));
 }
+function withoutKept(changes, kept) {
+    const slugs = new Set(kept.map((file) => file.slug));
+    return changes.filter((change) => !slugs.has(change.id));
+}
 function sha256(text) {
     return createHash('sha256').update(text, 'utf8').digest('hex');
 }

package/dist/commands/validate.js

@@ -11,6 +11,9 @@ export default class Validate extends Command {
             for (const problem of result.problems) {
                 this.log(`  ✗ ${problem.file}: ${problem.message}`);
             }
+            for (const warning of result.warnings) {
+                this.log(`  ! ${warning.file}: ${warning.message}`);
+            }
             this.log('');
             this.log(result.valid
                 ? `${result.checked} file(s) checked, no problems found.`

package/dist/config/auth.manager.d.ts

@@ -1,11 +1,13 @@
-export type ConsoleAuth = {
-    email?: string;
-    savedAt: string;
-    token: string;
-};
+import { z } from 'zod';
+declare const CONSOLE_AUTH: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    savedAt: z.ZodString;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type ConsoleAuth = z.infer<typeof CONSOLE_AUTH>;
 export declare class AuthManager {
-    private dataDir?;
-    constructor(dataDir?: string | undefined);
+    private dataDir;
+    constructor(dataDir?: string);
     clearAuth(): void;
     getAuth(): ConsoleAuth | null;
     getAuthFilePath(): string;
@@ -14,3 +16,4 @@ export declare class AuthManager {
     private requireDataDir;
 }
 export declare const authManager: AuthManager;
+export {};

package/dist/config/auth.manager.js

@@ -1,6 +1,8 @@
 import { existsSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
+import { z } from 'zod';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
+const CONSOLE_AUTH = z.object({ email: z.string().optional(), savedAt: z.string(), token: z.string() });
 export class AuthManager {
     dataDir;
     constructor(dataDir) {
@@ -12,7 +14,9 @@ export class AuthManager {
             unlinkSync(filePath);
     }
     getAuth() {
-        return readJsonFile(this.getAuthFilePath());
+        // A hand-edited or truncated auth.json reads as logged out, not as a token-less session.
+        const result = CONSOLE_AUTH.safeParse(readJsonFile(this.getAuthFilePath()));
+        return result.success ? result.data : null;
     }
     getAuthFilePath() {
         return join(this.requireDataDir(), 'auth.json');

package/dist/config/json-file.d.ts

@@ -1,2 +1,2 @@
-export declare function readJsonFile<T>(filePath: string): null | T;
+export declare function readJsonFile(filePath: string): unknown;
 export declare function writeJsonFileAtomic(filePath: string, data: unknown): void;

package/dist/config/project-config.manager.d.ts

@@ -1,7 +1,7 @@
 import { type EnvironmentConfig, type LoopressConfig, type ProjectConfig } from '../types/config.js';
 export declare class ProjectConfigManager {
-    private configDir?;
-    constructor(configDir?: string | undefined);
+    private configDir;
+    constructor(configDir?: string);
     createProjectId(name: string): string;
     ensureConfigDir(): void;
     findProjectByApiId(apiProjectId: string): null | (ProjectConfig & {

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;
 }