@loopress/cli 0.18.0 → 0.19.0

package/dist/commands/snippet/pull.js

@@ -1,10 +1,11 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-import slugify from 'slugify';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
-import { normalizeSnippet, SNIPPETS_ENDPOINT } from '../../utils/snippet-format.js';
+import { findOrphanedFiles, numericPrefixKey } from '../../lib/find-orphaned-files.js';
+import { buildMetaFile, buildSnippetFile, normalizeSnippet, SNIPPETS_ENDPOINT } from '../../utils/snippet-format.js';
+import { toSlug } from '../../utils/to-slug.js';
 const EXTENSIONS = {
     css: 'css',
     html: 'html',
@@ -12,32 +13,6 @@ const EXTENSIONS = {
     php: 'php',
     text: 'txt',
 };
-export function buildSnippetFile(snippet) {
-    if (snippet.type === 'php' && !snippet.code.trimStart().startsWith('<?')) {
-        return `<?php\n\n${snippet.code}`;
-    }
-    return snippet.code;
-}
-export function buildMetaFile(snippet) {
-    const meta = {
-        id: snippet.id,
-        name: snippet.name,
-        type: snippet.type,
-        active: snippet.active,
-        location: snippet.location,
-    };
-    if (snippet.description)
-        meta.description = snippet.description;
-    if (snippet.tags.length > 0)
-        meta.tags = snippet.tags;
-    if (snippet.insertMethod === 'shortcode')
-        meta.insertMethod = snippet.insertMethod;
-    if (snippet.priority !== 10)
-        meta.priority = snippet.priority;
-    if (snippet.shortcodeAttributes.length > 0)
-        meta.shortcodeAttributes = snippet.shortcodeAttributes;
-    return JSON.stringify(meta, null, 2) + '\n';
-}
 export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
@@ -46,6 +21,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps snippet pull', '$ lps snippet pull --path ./snippets'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Pull);
@@ -60,7 +36,10 @@ export default class Pull extends LoopressCommand {
         // Files following the `<id>-<slug>` convention whose id is no longer in the current
         // remote list belong to a snippet that was deleted on WordPress. Left on disk, they'd
         // silently come back to life the next time `snippet push` runs.
-        const orphans = await this.findOrphanedFiles(path, new Set(pullable.map((snippet) => snippet.id)));
+        const orphans = await findOrphanedFiles(path, new Set(pullable.map((snippet) => String(snippet.id))), {
+            extensions: ['.json', ...Object.values(EXTENSIONS).map((ext) => `.${ext}`)],
+            key: numericPrefixKey,
+        });
         if (this.dryRun) {
             this.log(`[dry-run] Would pull ${snippets.length} snippet${snippets.length === 1 ? '' : 's'} to ${path}`);
             if (orphans.length > 0) {
@@ -72,44 +51,17 @@ export default class Pull extends LoopressCommand {
         await new Listr(pullable.map((snippet) => ({
             async task(_ctx, task) {
                 const ext = EXTENSIONS[snippet.type];
-                const slug = slugify(snippet.name, { lower: true, strict: true });
-                const base = `${snippet.id}-${slug}`;
+                const base = `${snippet.id}-${toSlug(snippet.name)}`;
                 await writeFile(join(path, `${base}.${ext}`), buildSnippetFile(snippet));
                 await writeFile(join(path, `${base}.json`), buildMetaFile(snippet));
                 task.output = `Pulled: ${snippet.name}`;
             },
             title: `Pull ${snippet.name}`,
         }))).run();
-        for (const file of orphans)
-            await rm(join(path, file), { force: true });
-        if (orphans.length > 0) {
-            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} whose snippet no longer exists on WordPress: ${orphans.join(', ')}`);
-        }
+        await this.removeOrphanedFiles(path, orphans, 'whose snippet no longer exists on WordPress');
         this.log(`Pulled ${pullable.length} snippet${pullable.length === 1 ? '' : 's'} to ${path}`);
         if (skipped > 0) {
             this.warn(`${skipped} snippet${skipped === 1 ? '' : 's'} skipped because they have no name`);
         }
     }
-    // Only ever matches files already following the `<id>-<slug>` convention that `snippet
-    // pull`/`push` themselves produce, so a hand-created file without a numeric prefix is
-    // never at risk of being picked up here.
-    async findOrphanedFiles(path, keepIds) {
-        let files;
-        try {
-            files = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        const knownExtensions = new Set(['json', ...Object.values(EXTENSIONS)]);
-        return files.filter((file) => {
-            const ext = extname(file).slice(1);
-            if (!knownExtensions.has(ext))
-                return false;
-            const match = /^(\d+)-/.exec(file);
-            return match !== null && !keepIds.has(Number(match[1]));
-        });
-    }
 }

package/dist/commands/snippet/push.d.ts

@@ -6,9 +6,9 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<void>;
     private ensureCanonicalFilename;
     private loadSnippets;

package/dist/commands/snippet/push.js

@@ -2,11 +2,11 @@ import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
 import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
-import slugify from 'slugify';
 import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
+import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
@@ -15,8 +15,8 @@ export default class Push extends PushCommand {
     static examples = ['$ lps snippet push', '$ lps snippet push --path ./snippets'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
-    failedCount = 0;
     async run() {
         const { args } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -44,7 +44,7 @@ export default class Push extends PushCommand {
         const dir = dirname(snippet.path);
         const ext = extname(snippet.path);
         const currentBase = basename(snippet.path, ext);
-        const canonicalBase = `${id}-${slugify(name, { lower: true, strict: true })}`;
+        const canonicalBase = `${id}-${toSlug(name)}`;
         const oldMetaPath = join(dir, `${currentBase}.json`);
         let meta = {};
         try {
@@ -79,9 +79,6 @@ export default class Push extends PushCommand {
             this.error(error.message);
         }
     }
-    // Throwing on failure (rather than returning a boolean) is what lets Listr mark the task as
-    // failed (red cross) instead of completed; `exitOnError: false` on the task list still lets
-    // sibling snippets push regardless.
     async pushSnippet(snippet, task) {
         if (this.dryRun) {
             if (task)
@@ -114,13 +111,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${snippet.name}`;
         }
         catch (error) {
-            const message = `Failed to push ${snippet.name}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${snippet.name}: ${error.message}`, error, task);
         }
     }
     toPayload(snippet) {

package/dist/commands/status.d.ts

@@ -2,7 +2,11 @@ import { Command } from '@oclif/core';
 export default class Status extends Command {
     static description: string;
     static examples: string[];
+    static flags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     run(): Promise<void>;
     private reportActiveProject;
+    private reportEnvOverride;
     private reportPinnedProject;
 }

package/dist/commands/status.js

@@ -1,14 +1,20 @@
-import { Command, ux } from '@oclif/core';
+import { Command, Flags, ux } from '@oclif/core';
 import { configManager } from '../config/project-config.manager.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 const c = ux.colorize;
 export default class Status extends Command {
     static description = 'Show which WordPress project and environment commands will target';
-    static examples = ['$ lps status'];
+    static examples = ['$ lps status', '$ lps status --env staging'];
+    static flags = {
+        env: Flags.string({ description: 'Show what would be targeted with this environment, as other commands do with --env' }),
+    };
     async run() {
-        await this.parse(Status);
+        const { flags } = await this.parse(Status);
         const localConfig = await readLocalConfig();
-        if (localConfig.projectId) {
+        if (flags.env) {
+            this.reportEnvOverride(localConfig.projectId, flags.env);
+        }
+        else if (localConfig.projectId) {
             this.reportPinnedProject(localConfig.projectId);
         }
         else {
@@ -32,6 +38,21 @@ export default class Status extends Command {
         this.log(`Project:  ${project.name} (${env.name})`);
         this.log(`URL:      ${env.url}`);
     }
+    // Mirrors base.ts:resolveEnvironment with --env: the targeted project comes from
+    // loopress.json when pinned, from the globally active project otherwise.
+    reportEnvOverride(pinnedProjectId, envName) {
+        const project = pinnedProjectId ? configManager.getProject(pinnedProjectId) : configManager.getCurrentProject();
+        if (!project) {
+            this.log('No project configured. Run `lps project config` first.');
+            return;
+        }
+        const env = project.environments[envName];
+        if (!env) {
+            this.error(`Environment "${envName}" not found in project "${project.name}". Available: ${Object.keys(project.environments).join(', ')}`);
+        }
+        this.log(`Project:  ${project.name} (${env.name}, via --env)`);
+        this.log(`URL:      ${env.url}`);
+    }
     reportPinnedProject(projectId) {
         const project = configManager.getProject(projectId);
         if (!project) {

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

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import slugify from 'slugify';
+import { toSlug } from '../utils/to-slug.js';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
     configDir;
@@ -9,7 +9,7 @@ export class ProjectConfigManager {
     }
     createProjectId(name) {
         const config = this.readConfig();
-        const base = slugify(name, { lower: true, strict: true }) || 'project';
+        const base = toSlug(name, 'project');
         let id = base;
         let suffix = 2;
         while (config.projects[id]) {

package/dist/lib/api-client.d.ts

@@ -6,7 +6,8 @@ export declare const API_URL: string;
 export declare class ApiClient {
     private readonly baseUrl;
     private readonly client;
-    constructor(token: string, baseUrl?: string);
+    private readonly timeoutMs;
+    constructor(token: string, baseUrl?: string, timeoutMs?: number);
     get<T = unknown>(path: string): Promise<T>;
     post<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;
     put<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;

package/dist/lib/api-client.js

@@ -1,4 +1,5 @@
 import got from 'got';
+import { REQUEST_TIMEOUT_MS } 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).
@@ -7,11 +8,14 @@ export const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
 export class ApiClient {
     baseUrl;
     client;
-    constructor(token, baseUrl = API_URL) {
+    timeoutMs;
+    constructor(token, baseUrl = API_URL, timeoutMs = REQUEST_TIMEOUT_MS) {
         this.baseUrl = baseUrl;
+        this.timeoutMs = timeoutMs;
         this.client = got.extend({
             headers: { Authorization: `Bearer ${token}` },
             prefixUrl: baseUrl,
+            timeout: { request: timeoutMs },
         });
     }
     async get(path) {
@@ -29,11 +33,11 @@ export class ApiClient {
             return (response.body ? JSON.parse(response.body) : undefined);
         }
         catch (error) {
-            throw new Error(formatApiError(error, `${this.baseUrl}/${path}`), { cause: error });
+            throw new Error(formatApiError(error, `${this.baseUrl}/${path}`, this.timeoutMs), { cause: error });
         }
     }
 }
-function formatApiError(error, url) {
+function formatApiError(error, url, timeoutMs) {
     const err = error;
     const status = err.response?.statusCode;
     if (status === 401) {
@@ -42,5 +46,8 @@ function formatApiError(error, url) {
     if (status === 403) {
         return `Request rejected (${status}) on ${url}: ${err.response?.body ?? err.message}`;
     }
+    if (err.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);
 }

package/dist/lib/base.d.ts

@@ -3,20 +3,29 @@ import { EnvironmentConfig } from '../types/config.js';
 import { LoopressLocalConfig } from '../utils/loopress-config.js';
 import { WpClient } from './wp-client.js';
 export declare abstract class LoopressCommand extends Command {
+    static baseFlags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     static dryRunFlag: {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    static yesFlag: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     protected dryRun: boolean;
     protected localConfig: LoopressLocalConfig;
     protected siteConfig: EnvironmentConfig;
+    protected yes: boolean;
     private wpClient?;
     protected get rootDir(): string;
     protected get wp(): WpClient;
     init(): Promise<void>;
+    protected removeOrphanedFiles(dir: string, orphans: string[], reason: string): Promise<void>;
     protected resolveAcfPath(override?: string): string;
     protected resolveApiPath(override?: string): string;
     protected resolveFormPath(override?: string): string;
     protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
+    private pickEnvironment;
     private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -1,15 +1,29 @@
+import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
+import { rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
+import { isInteractive } from './interactive.js';
 import { WpClient } from './wp-client.js';
 export class LoopressCommand extends Command {
+    // On every subclass without opt-in: targeting an environment explicitly beats depending on
+    // the machine-wide mutable state of `lps project switch`, which is shared across terminals.
+    static baseFlags = {
+        env: Flags.string({
+            description: 'Target environment by name, overriding the globally active one (lps project switch)',
+        }),
+    };
     static dryRunFlag = {
         'dry-run': Flags.boolean({ char: 'd', description: 'Show what would change without making changes' }),
     };
+    static yesFlag = {
+        yes: Flags.boolean({ char: 'y', description: 'Answer yes to confirmation prompts' }),
+    };
     dryRun = false;
     localConfig = {};
     siteConfig;
+    yes = false;
     wpClient;
     get rootDir() {
         return this.localConfig.rootDir ?? '.';
@@ -28,12 +42,41 @@ export class LoopressCommand extends Command {
         await super.init();
         const { flags } = (await this.parse({
             args: this.ctor.args,
+            baseFlags: this.ctor.baseFlags,
             flags: this.ctor.flags,
             strict: this.ctor.strict,
         }));
         this.dryRun = Boolean(flags['dry-run']);
+        this.yes = Boolean(flags.yes);
         this.localConfig = await readLocalConfig();
-        this.siteConfig = this.resolveEnvironment();
+        this.siteConfig = this.resolveEnvironment(flags.env);
+    }
+    // Orphan cleanup shared by every pull command (see Push Deletion Rules in the product docs):
+    // in a TTY the list is shown and confirmed first (Enter accepts), --yes skips the prompt, and
+    // outside a TTY the files are removed with a warning, the behavior scripts relied on before
+    // the confirmation existed.
+    async removeOrphanedFiles(dir, orphans, reason) {
+        if (orphans.length === 0)
+            return;
+        const description = `${orphans.length} local file${orphans.length === 1 ? '' : 's'} ${reason}: ${orphans.join(', ')}`;
+        if (!this.yes && isInteractive()) {
+            const proceed = await confirm({ default: true, message: `Remove ${description}?` });
+            if (!proceed) {
+                this.log(`Kept ${description}`);
+                return;
+            }
+        }
+        for (const file of orphans)
+            await rm(join(dir, file), { force: true });
+        // Non-interactive removals (no TTY, CI) keep the original warn so existing
+        // scripts that parse stderr or check exit status are not broken. Confirmed
+        // interactive removals are intentional, so log() is appropriate.
+        if (this.yes || isInteractive()) {
+            this.log(`Removed ${description}`);
+        }
+        else {
+            this.warn(`Removed ${description}`);
+        }
     }
     resolveAcfPath(override) {
         if (override)
@@ -60,7 +103,14 @@ export class LoopressCommand extends Command {
             return override;
         return join(this.rootDir, this.localConfig.snippetsDir ?? 'snippets');
     }
-    resolveEnvironment() {
+    pickEnvironment(project, envName) {
+        const env = project.environments[envName];
+        if (!env) {
+            this.error(`Environment "${envName}" not found in project "${project.name}". Available: ${Object.keys(project.environments).join(', ')}`);
+        }
+        return env;
+    }
+    resolveEnvironment(envName) {
         if (this.localConfig.projectId) {
             const project = configManager.getProject(this.localConfig.projectId);
             if (!project) {
@@ -70,6 +120,8 @@ export class LoopressCommand extends Command {
             if (envNames.length === 0) {
                 this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
             }
+            if (envName)
+                return this.pickEnvironment(project, envName);
             if (envNames.length === 1) {
                 return project.environments[envNames[0]];
             }
@@ -80,6 +132,13 @@ export class LoopressCommand extends Command {
             }
             return currentEnv;
         }
+        if (envName) {
+            const current = configManager.getCurrentProject();
+            if (!current) {
+                this.error('No project configured. Run `lps project config` first.');
+            }
+            return this.pickEnvironment(current, envName);
+        }
         const env = configManager.getCurrentEnv();
         if (env)
             return env;

package/dist/lib/find-orphaned-files.d.ts

@@ -0,0 +1,7 @@
+export interface OrphanMatcher {
+    extensions: string[];
+    key(base: string): null | string;
+}
+export declare function findOrphanedFiles(dir: string, keep: Set<string>, matcher: OrphanMatcher): Promise<string[]>;
+export declare function numericPrefixKey(base: string): null | string;
+export declare function basenameKey(base: string): string;

package/dist/lib/find-orphaned-files.js

@@ -0,0 +1,29 @@
+import { readdir } from 'node:fs/promises';
+import { extname } from 'node:path';
+export async function findOrphanedFiles(dir, keep, matcher) {
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    return files.filter((file) => {
+        const ext = extname(file);
+        if (!matcher.extensions.includes(ext))
+            return false;
+        const key = matcher.key(file.slice(0, -ext.length));
+        return key !== null && !keep.has(key);
+    });
+}
+// The `<id>-<slug>.*` filename convention: the numeric prefix is the identity.
+export function numericPrefixKey(base) {
+    const match = /^(\d+)-/.exec(base);
+    return match?.[1] ?? null;
+}
+// The `<key>.<ext>` filename convention: the whole basename is the identity.
+export function basenameKey(base) {
+    return base;
+}

package/dist/lib/interactive.d.ts

@@ -0,0 +1 @@
+export declare function isInteractive(): boolean;

package/dist/lib/interactive.js

@@ -0,0 +1,7 @@
+// Whether prompts can be shown at all: a real terminal on both ends, and not a CI runner.
+// CI=1 with a pseudo-TTY still counts as non-interactive, which is what CI users expect.
+// Every command that prompts routes its decision through this so the CLI never hangs on a
+// question nobody can answer.
+export function isInteractive() {
+    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !process.env.CI;
+}

package/dist/lib/load-files.d.ts

@@ -0,0 +1,5 @@
+export declare function loadFiles<T>(dir: string, options: {
+    extension: string;
+    onSkip(message: string): void;
+    parse(raw: string, filePath: string): T;
+}): Promise<T[]>;

package/dist/lib/load-files.js

@@ -0,0 +1,31 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+// Loads every `<extension>` file of a flat directory through `parse`. One file is read in
+// isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
+// only skip that file, never abort loading the rest of the directory, so `parse` throwing is
+// reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
+// "nothing to load", not an error.
+export async function loadFiles(dir, options) {
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const items = [];
+    for (const entry of entries) {
+        if (extname(entry) !== options.extension)
+            continue;
+        const filePath = join(dir, entry);
+        try {
+            items.push(options.parse(await readFile(filePath, 'utf8'), filePath));
+        }
+        catch (error) {
+            options.onSkip(`Skipping "${filePath}": ${error.message}`);
+        }
+    }
+    return items;
+}

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

@@ -1,6 +1,13 @@
 import { LoopressCommand } from './base.js';
 export declare abstract class PushCommand extends LoopressCommand {
+    protected failedCount: number;
+    private refusedByGuard;
     catch(err: Error): Promise<void>;
+    protected guardProductionPush(): Promise<void>;
+    init(): Promise<void>;
     protected recordDeployment(status: 'failure' | 'success'): Promise<void>;
     protected recordSuccess(): Promise<void>;
+    protected reportTaskFailure(message: string, error: unknown, task?: {
+        output: string;
+    }): never;
 }

package/dist/lib/push-command.js

@@ -1,14 +1,39 @@
+import { confirm } from '@inquirer/prompts';
 import got from 'got';
 import { authManager } from '../config/auth.manager.js';
+import { API_URL } from './api-client.js';
 import { LoopressCommand } from './base.js';
-const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
+import { isInteractive } from './interactive.js';
 export class PushCommand extends LoopressCommand {
+    failedCount = 0;
+    // Refusals of the production guard never reach the site, so they must not pollute the
+    // deployment history with failure records.
+    refusedByGuard = false;
     async catch(err) {
-        if (!this.dryRun && this.siteConfig) {
+        if (!this.dryRun && !this.refusedByGuard && this.siteConfig) {
             await this.recordDeployment('failure');
         }
         return super.catch(err);
     }
+    // Pushing to an environment named "production" needs explicit intent: a TTY confirmation
+    // (Enter accepts), or --yes in scripts and CI. Dry runs are exempt, they change nothing.
+    async guardProductionPush() {
+        if (this.siteConfig.name.toLowerCase() !== 'production' || this.dryRun || this.yes)
+            return;
+        if (!isInteractive()) {
+            this.refusedByGuard = true;
+            this.error('Target environment is "production". Pass --yes to confirm the push in a non-interactive run.');
+        }
+        const proceed = await confirm({ default: true, message: `Push to production (${this.siteConfig.url})?` });
+        if (!proceed) {
+            this.refusedByGuard = true;
+            this.error('Aborted.');
+        }
+    }
+    async init() {
+        await super.init();
+        await this.guardProductionPush();
+    }
     async recordDeployment(status) {
         const token = process.env.LOOPRESS_TOKEN ?? authManager.getAuth()?.token ?? null;
         if (!token)
@@ -28,4 +53,17 @@ export class PushCommand extends LoopressCommand {
         if (!this.dryRun)
             await this.recordDeployment('success');
     }
+    // Reports one failed Listr task: status lines go through `task.output` when running inside a
+    // Listr renderer (this.warn would race with the repaint), and fall back to `this.warn` when
+    // called without a task (e.g. directly in tests). Rethrowing is what lets Listr mark the task
+    // failed (red cross) instead of completed; `exitOnError: false` on the list still lets sibling
+    // tasks run, and the accumulated `failedCount` drives the command's final "N failed" error.
+    reportTaskFailure(message, error, task) {
+        if (task)
+            task.output = message;
+        else
+            this.warn(`  ${message}`);
+        this.failedCount++;
+        throw error;
+    }
 }

package/dist/lib/wp-client.d.ts

@@ -7,10 +7,15 @@ export declare class WpClient {
     private readonly siteUrl;
     private readonly client;
     constructor(siteUrl: string, token: string);
-    get<T>(path: string): Promise<T>;
-    post<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;
-    put<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
     private request;
 }
+interface RequestOptions {
+    timeoutMs?: number;
+}
 export declare function isNotFoundError(error: unknown): boolean;
-export declare function formatWpError(error: unknown, url: string): string;
+export declare function isTimeoutError(error: unknown): boolean;
+export declare function formatWpError(error: unknown, url: string, timeoutMs?: number): string;
+export {};