@loopress/cli 0.21.0 → 0.23.0

package/dist/commands/theme/push.js

@@ -0,0 +1,130 @@
+import { confirm } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { isInteractive } from '../../lib/interactive.js';
+import { PushCommand } from '../../lib/push-command.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS } from '../../utils/plugin-sync.js';
+import { lockedWpackagistSlugs } from '../../utils/plugins.js';
+import { diffThemes, parseInstalledThemes } from '../../utils/themes.js';
+const IN_SYNC = { installed: [], pinned: [], removed: [], status: 'in-sync' };
+export default class Push extends PushCommand {
+    static description = 'Install themes on WordPress to match loopress.json (versions only, never switches the active theme)';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme push', '$ lps theme push --force'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+        force: Flags.boolean({ default: false, description: 'Allow downgrades and take over themes installed outside Loopress' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Push);
+        const { force } = flags;
+        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
+            this.warn('This project has a composer.json, which is authoritative. Run `lps composer push` instead.');
+            return { ...IN_SYNC, status: 'composer-managed' };
+        }
+        const manifest = this.localConfig.themes ?? {};
+        if (Object.keys(manifest).length === 0) {
+            this.error('No themes found in loopress.json. Run `lps theme pull` first.');
+        }
+        this.log(`Pushing themes to ${this.siteConfig.url}`);
+        const raw = await this.wp.get('wp/v2/themes');
+        const installed = parseInstalledThemes(raw);
+        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'theme');
+        const diff = diffThemes(manifest, installed, managed);
+        this.guardForce(diff, force);
+        // Uninstalling the theme WordPress is currently rendering leaves the site with no active
+        // theme, which is a hard fatal. --force does not override this: switch the active theme
+        // on the site first, then the removal is safe. A --force takeover of a collision hits the
+        // same fatal: the server moves the existing folder out of the way before reinstalling it,
+        // so the active theme is briefly missing either way, an active collision is just as
+        // dangerous as an active removal.
+        const activeRemoval = [...diff.toRemove, ...diff.collisions.map((c) => c.slug)].find((slug) => installed.find((t) => t.slug === slug)?.active);
+        if (activeRemoval) {
+            this.error(`Refusing to uninstall "${activeRemoval}": it is the site's active theme. ` +
+                'Switch the site to another theme, then re-run to remove it.');
+        }
+        // A "latest" pin never shows as drift, but its newest upstream release may have moved, so
+        // a push must still run `composer update` to pick it up.
+        const hasLatestPin = Object.values(manifest).includes('latest');
+        if (!hasLatestPin && isNoop(diff)) {
+            this.log('Everything is already in sync.');
+            return { ...IN_SYNC };
+        }
+        if (isNoop(diff))
+            this.log('Refreshing themes pinned to "latest" to their newest releases.');
+        for (const a of diff.toInstall)
+            this.log(`  + ${a.slug} ${a.version}`);
+        for (const p of diff.toPin)
+            this.log(`  ~ ${p.slug} ${p.from} to ${p.to}`);
+        for (const s of diff.toRemove)
+            this.log(`  - ${s}`);
+        for (const c of diff.collisions)
+            this.log(`  ! ${c.slug} (take over)`);
+        if (this.dryRun)
+            return result(diff, 'dry-run', diff.toRemove, true);
+        await this.confirmRemovals(diff.toRemove);
+        const response = await this.sync(manifest, force);
+        if (response.output.trim())
+            this.log(response.output.trim());
+        this.log('Themes synced.');
+        await this.recordSuccess();
+        return result(diff, 'success', response.removed ?? diff.toRemove, force);
+    }
+    async confirmRemovals(toRemove) {
+        if (toRemove.length === 0 || this.yes || !isInteractive())
+            return;
+        const ok = await confirm({ default: false, message: `Uninstall ${toRemove.join(', ')} from the site?` });
+        if (!ok)
+            this.error('Aborted.');
+    }
+    async fetchInstanceLock() {
+        try {
+            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+            return composerLock;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+    }
+    guardForce(diff, force) {
+        if (force)
+            return;
+        if (diff.collisions.length > 0) {
+            const list = diff.collisions.map((c) => `${c.slug} (${c.installedVersion})`).join(', ');
+            this.error(`${list} installed outside Loopress. Re-run with --force to take them over, or remove them from loopress.json.`);
+        }
+        const downgrades = diff.toPin.filter((p) => isDowngrade(p.from, p.to));
+        if (downgrades.length > 0) {
+            const list = downgrades.map((p) => `${p.slug} ${p.from} to ${p.to}`).join(', ');
+            this.error(`Refusing to downgrade: ${list}. Re-run with --force.`);
+        }
+    }
+    async sync(manifest, force) {
+        try {
+            return await this.wp.post('loopress/v1/composer/sync', { force, intent: { themes: manifest }, lock: null }, { timeoutMs: SYNC_TIMEOUT_MS });
+        }
+        catch (error) {
+            if (parseCollisions(error)) {
+                this.error('The site rejected the push: themes installed outside Loopress. Re-run with --force.');
+            }
+            throw error;
+        }
+    }
+}
+function isNoop(diff) {
+    return (diff.toInstall.length === 0 && diff.toPin.length === 0 && diff.toRemove.length === 0 && diff.collisions.length === 0);
+}
+function result(diff, status, removed, includeCollisions) {
+    const collisionSlugs = includeCollisions ? diff.collisions.map((c) => c.slug) : [];
+    return {
+        installed: [...diff.toInstall.map((a) => a.slug), ...collisionSlugs],
+        pinned: diff.toPin.map((p) => p.slug),
+        removed,
+        status,
+    };
+}

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

@@ -0,0 +1,20 @@
+import { LoopressCommand } from '../../lib/base.js';
+type StatusResult = {
+    drift: boolean;
+    missing: string[];
+    status: 'composer-managed' | 'drift' | 'in-sync';
+    wrongVersion: Array<{
+        live: string;
+        pinned: string;
+        slug: string;
+    }>;
+};
+export default class Status extends LoopressCommand {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {};
+    run(): Promise<StatusResult>;
+    private fetchInstanceLock;
+}
+export {};

package/dist/commands/theme/status.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { lockedWpackagistSlugs } from '../../utils/plugins.js';
+import { diffThemes, parseInstalledThemes } from '../../utils/themes.js';
+export default class Status extends LoopressCommand {
+    static description = 'Compare the themes on WordPress against loopress.json and report version drift';
+    static enableJsonFlag = true;
+    static examples = ['$ lps theme status'];
+    static flags = {};
+    async run() {
+        const { url } = this.siteConfig;
+        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
+            this.warn('This project has a composer.json, which is authoritative. Run `lps composer` commands instead.');
+            return { drift: false, missing: [], status: 'composer-managed', wrongVersion: [] };
+        }
+        const manifest = this.localConfig.themes ?? {};
+        const raw = await this.wp.get('wp/v2/themes');
+        const installed = parseInstalledThemes(raw);
+        const managed = lockedWpackagistSlugs(await this.fetchInstanceLock(), 'theme');
+        const diff = diffThemes(manifest, installed, managed);
+        const missing = [...diff.toInstall.map((a) => a.slug), ...diff.collisions.map((c) => c.slug)];
+        const wrongVersion = diff.toPin.map((p) => ({ live: p.from, pinned: p.to, slug: p.slug }));
+        const drift = missing.length > 0 || wrongVersion.length > 0 || diff.toRemove.length > 0;
+        if (!drift) {
+            this.log(`In sync with loopress.json (${url})`);
+            return { drift: false, missing: [], status: 'in-sync', wrongVersion: [] };
+        }
+        if (diff.toInstall.length > 0)
+            this.log(`Not installed: ${diff.toInstall.map((a) => a.slug).join(', ')}`);
+        if (diff.collisions.length > 0)
+            this.log(`Installed outside Loopress: ${diff.collisions.map((c) => c.slug).join(', ')}`);
+        for (const w of wrongVersion)
+            this.log(`Version drift: ${w.slug} is ${w.live}, loopress.json pins ${w.pinned}`);
+        if (diff.toRemove.length > 0)
+            this.log(`Managed by Loopress but dropped from loopress.json: ${diff.toRemove.join(', ')}`);
+        this.exit(1);
+    }
+    async fetchInstanceLock() {
+        try {
+            const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
+            return composerLock;
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return null;
+            throw error;
+        }
+    }
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+import { type ValidateResult } from '../lib/validate-local.js';
+export default class Validate extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    run(): Promise<ValidateResult>;
+}

package/dist/commands/validate.js

@@ -0,0 +1,24 @@
+import { Command } from '@oclif/core';
+import { validateLocal } from '../lib/validate-local.js';
+export default class Validate extends Command {
+    static description = 'Check local tracked files are well formed and push-ready, without contacting WordPress';
+    static enableJsonFlag = true;
+    static examples = ['$ lps validate'];
+    async run() {
+        await this.parse(Validate);
+        const result = await validateLocal(process.cwd());
+        if (!this.jsonEnabled()) {
+            for (const problem of result.problems) {
+                this.log(`  ✗ ${problem.file}: ${problem.message}`);
+            }
+            this.log('');
+            this.log(result.valid
+                ? `${result.checked} file(s) checked, no problems found.`
+                : `${result.checked} file(s) checked, ${result.problems.length} problem(s) found.`);
+        }
+        // Non-zero exit for CI without throwing, so `--json` still prints the full report.
+        if (!result.valid)
+            process.exitCode = 1;
+        return result;
+    }
+}

package/dist/lib/app-manifest.d.ts

@@ -0,0 +1,36 @@
+export type AppFile = {
+    path: string;
+    sha256: string;
+    size: number;
+};
+export type AppEntry = {
+    scripts: string[];
+    styles: string[];
+};
+export type AppConfigFile = {
+    assetsDir?: string;
+    entry?: AppEntry;
+    mountSelector?: string;
+    name?: string;
+    routing?: string;
+};
+export type AppManifest = {
+    buildId: string;
+    entry: AppEntry;
+    files: AppFile[];
+    mountSelector: string;
+    name: string;
+    routing: 'hash';
+};
+export declare const APP_CONFIG_FILENAME = "loopress.app.json";
+export declare function isAllowedAsset(relPath: string): boolean;
+export declare function buildFileList(distDir: string): Promise<AppFile[]>;
+export declare function computeBuildId(files: AppFile[]): string;
+export declare function deriveEntry(indexHtml: string): AppEntry;
+export declare function diffFiles(local: AppFile[], remote: AppFile[]): AppFile[];
+export declare function parseAppConfig(raw: string, appDir: string): AppConfigFile;
+export declare function loadAppManifest(appDir: string, dirName: string): Promise<{
+    configPath: string;
+    distDir: string;
+    manifest: AppManifest;
+}>;

package/dist/lib/app-manifest.js

@@ -0,0 +1,162 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, join, relative } from 'node:path';
+export const APP_CONFIG_FILENAME = 'loopress.app.json';
+const DEFAULT_ASSETS_DIR = 'dist';
+// Static assets a bundler emits, mirrors the server's AppsDirectory::ALLOWED_EXTENSIONS.
+// `.php` and friends are absent on purpose: these files are served straight off wp-content/.
+const ALLOWED_EXTENSIONS = new Set([
+    '.avif', '.bmp', '.cjs', '.css', '.csv', '.eot', '.gif', '.htm', '.html', '.ico', '.jpeg',
+    '.jpg', '.js', '.json', '.map', '.mjs', '.mp3', '.mp4', '.ogg', '.otf',
+    '.pdf', '.png', '.svg', '.ttf', '.txt',
+    '.wasm', '.webm', '.webmanifest', '.webp', '.woff', '.woff2', '.xml',
+]);
+export function isAllowedAsset(relPath) {
+    return ALLOWED_EXTENSIONS.has(extname(relPath).toLowerCase());
+}
+async function walk(dir, root) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const out = [];
+    for (const entry of entries) {
+        const abs = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...(await walk(abs, root)));
+        }
+        else if (entry.isFile()) {
+            // Identity is always '/'-joined, never the OS separator: it travels over HTTP and is
+            // matched against the server's own '/'-joined paths.
+            out.push(relative(root, abs).replaceAll(/[\\/]/g, '/'));
+        }
+    }
+    return out;
+}
+// Builds the sorted file list of a dist directory. Throws on a file whose extension the
+// server would reject, so the push fails locally with a clear message instead of a 400
+// halfway through the upload.
+export async function buildFileList(distDir) {
+    const relPaths = (await walk(distDir, distDir)).sort((a, b) => a.localeCompare(b));
+    const files = [];
+    for (const path of relPaths) {
+        if (!isAllowedAsset(path)) {
+            throw new Error(`${path}: extension ${extname(path) || '(none)'} is not an allowed static asset. Remove it from the build output or the bundle.`);
+        }
+        const buf = await readFile(join(distDir, path));
+        files.push({ path, sha256: createHash('sha256').update(buf).digest('hex'), size: buf.length });
+    }
+    return files;
+}
+// A stable content hash of the whole build: changes if and only if some file's bytes change.
+// Used as the enqueue `?ver` (cache busting) and as the build identity in `app list`.
+export function computeBuildId(files) {
+    const digest = createHash('sha256');
+    for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+        digest.update(`${file.path}:${file.sha256}\n`);
+    }
+    return digest.digest('hex').slice(0, 12);
+}
+function normalizeAssetUrl(url) {
+    let path = url.trim();
+    const schemeMatch = /^(?:[a-z]+:)?\/\/[^/]+(\/.*)$/i.exec(path);
+    if (schemeMatch)
+        path = schemeMatch[1];
+    path = path.replace(/^\.?\//, '');
+    return path;
+}
+// Reads the <script type="module"> and <link rel="stylesheet"> the build's own index.html
+// declares. This is what a bundler already writes; Loopress does not guess or reorder.
+export function deriveEntry(indexHtml) {
+    const scripts = [];
+    for (const tag of indexHtml.match(/<script\b[^>]*>/gi) ?? []) {
+        if (!/\btype=["']module["']/i.test(tag))
+            continue;
+        const src = /\bsrc=["']([^"']+)["']/i.exec(tag);
+        if (src)
+            scripts.push(normalizeAssetUrl(src[1]));
+    }
+    const styles = [];
+    for (const tag of indexHtml.match(/<link\b[^>]*>/gi) ?? []) {
+        if (!/\brel=["']stylesheet["']/i.test(tag))
+            continue;
+        const href = /\bhref=["']([^"']+)["']/i.exec(tag);
+        if (href)
+            styles.push(normalizeAssetUrl(href[1]));
+    }
+    return { scripts, styles };
+}
+// Files new on this build or whose hash moved. Deletions are handled server-side on commit
+// (with a one-generation grace for in-flight sessions), never by this diff.
+export function diffFiles(local, remote) {
+    const remoteByPath = new Map(remote.map((file) => [file.path, file.sha256]));
+    return local.filter((file) => remoteByPath.get(file.path) !== file.sha256);
+}
+export function parseAppConfig(raw, appDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${join(appDir, APP_CONFIG_FILENAME)} is not valid JSON`);
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error(`${join(appDir, APP_CONFIG_FILENAME)} must be a JSON object`);
+    }
+    const config = parsed;
+    if (config.routing !== undefined && config.routing !== 'hash') {
+        throw new Error(`${join(appDir, APP_CONFIG_FILENAME)}: routing "${config.routing}" is not supported, only "hash" works without a server rewrite`);
+    }
+    return config;
+}
+// Assembles the full manifest for one app directory: reads loopress.app.json, hashes the
+// dist directory, derives the entry from index.html (or takes it from the config), computes
+// the build id.
+export async function loadAppManifest(appDir, dirName) {
+    const configPath = join(appDir, APP_CONFIG_FILENAME);
+    const config = parseAppConfig(await readFile(configPath, 'utf8'), appDir);
+    const name = config.name ?? dirName;
+    if (!/^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/.test(name)) {
+        throw new Error(`Invalid app name "${name}": lowercase letters, digits and hyphens only, no leading or trailing hyphen`);
+    }
+    const distDir = join(appDir, config.assetsDir ?? DEFAULT_ASSETS_DIR);
+    const files = await buildFileList(distDir);
+    if (files.length === 0) {
+        throw new Error(`No files in ${distDir}. Build the app first, then run \`lps app push\`.`);
+    }
+    const filePaths = new Set(files.map((file) => file.path));
+    let entry;
+    if (config.entry) {
+        entry = config.entry;
+    }
+    else if (filePaths.has('index.html')) {
+        entry = deriveEntry(await readFile(join(distDir, 'index.html'), 'utf8'));
+    }
+    else {
+        throw new Error(`${distDir} has no index.html to read the entry from. Add an "entry" object to ${APP_CONFIG_FILENAME}.`);
+    }
+    const missing = [...entry.scripts, ...entry.styles].filter((ref) => !filePaths.has(ref));
+    if (missing.length > 0) {
+        throw new Error(`Entry references files not in the build output: ${missing.join(', ')}`);
+    }
+    if (entry.scripts.length === 0) {
+        throw new Error(`No <script type="module"> entry found for app "${name}".`);
+    }
+    return {
+        configPath,
+        distDir,
+        manifest: {
+            buildId: computeBuildId(files),
+            entry,
+            files,
+            mountSelector: config.mountSelector ?? `#loopress-app-${name}`,
+            name,
+            routing: 'hash',
+        },
+    };
+}

package/dist/lib/base.d.ts

@@ -22,13 +22,23 @@ export declare abstract class LoopressCommand extends Command {
     protected get wp(): WpClient;
     init(): Promise<void>;
     protected maybeAutoRotate(): Promise<void>;
+    protected pullDirectory<T>(dir: string, items: T[], orphans: string[], options: {
+        alwaysCreateDir?: boolean;
+        dryRunMessage: string;
+        orphanReason: string;
+        pulledMessage: string;
+        title: (item: T) => string;
+        write: (item: T, dir: string) => Promise<void>;
+    }): Promise<void>;
     protected removeOrphanedFiles(dir: string, orphans: string[], reason: string): Promise<void>;
     protected resolveAcfPath(override?: string): string;
     protected resolveApiPath(override?: string): string;
+    protected resolveAppsPath(override?: string): string;
     protected resolveFormPath(override?: string): string;
     protected resolvePagePath(override?: string): string;
     protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     private pickEnvironment;
     private resolveEnvironment;
+    private resolveEnvironmentForConfiguredProject;
 }

package/dist/lib/base.js

@@ -1,9 +1,11 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
-import { rm } from 'node:fs/promises';
+import { Listr } from 'listr2';
+import { mkdir, 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 { pluralize } from '../utils/pluralize.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
 import { WpClient } from './wp-client.js';
@@ -77,6 +79,31 @@ export class LoopressCommand extends Command {
             // swallowed: see comment above
         }
     }
+    // Shared shape of every resource's directory pull: write each item, then reconcile local
+    // files against the remote list (see removeOrphanedFiles above). `dryRunMessage` and
+    // `pulledMessage` are fully-formed by the caller (label pluralization varies per resource,
+    // e.g. ACF's `type` is a fixed category name, never pluralized), the "[dry-run] Would "
+    // prefix and the orphans notice are the only wording this method owns.
+    async pullDirectory(dir, items, orphans, options) {
+        if (this.dryRun) {
+            this.log(`[dry-run] ${options.dryRunMessage}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${pluralize(orphans.length, 'local file')} ${options.orphanReason}: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        if (options.alwaysCreateDir === true || items.length > 0)
+            await mkdir(dir, { recursive: true });
+        await new Listr(items.map((item) => ({
+            async task(_ctx, task) {
+                await options.write(item, dir);
+                task.output = `Pulled: ${options.title(item)}`;
+            },
+            title: `Pull ${options.title(item)}`,
+        })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        await this.removeOrphanedFiles(dir, orphans, options.orphanReason);
+        this.log(options.pulledMessage);
+    }
     // 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
@@ -84,7 +111,7 @@ export class LoopressCommand extends Command {
     async removeOrphanedFiles(dir, orphans, reason) {
         if (orphans.length === 0)
             return;
-        const description = `${orphans.length} local file${orphans.length === 1 ? '' : 's'} ${reason}: ${orphans.join(', ')}`;
+        const description = `${pluralize(orphans.length, 'local file')} ${reason}: ${orphans.join(', ')}`;
         if (!this.yes && isInteractive()) {
             const isProceed = await confirm({ default: true, message: `Remove ${description}?` });
             if (!isProceed) {
@@ -114,6 +141,11 @@ export class LoopressCommand extends Command {
             return override;
         return join(this.rootDir, this.localConfig.apiDir ?? 'api');
     }
+    resolveAppsPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.appsDir ?? 'apps');
+    }
     resolveFormPath(override) {
         if (override)
             return override;
@@ -143,26 +175,7 @@ export class LoopressCommand extends Command {
     }
     resolveEnvironment(envName) {
         if (this.localConfig.projectId) {
-            const { projectId } = this.localConfig;
-            const project = configManager.getProject(projectId);
-            if (!project) {
-                this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
-            }
-            const envNames = Object.keys(project.environments);
-            if (envNames.length === 0) {
-                this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
-            }
-            if (envName)
-                return { env: this.pickEnvironment(project, envName), projectId };
-            if (envNames.length === 1) {
-                return { env: project.environments[envNames[0]], projectId };
-            }
-            const current = configManager.getCurrentProject();
-            const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
-            if (!currentEnv) {
-                this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
-            }
-            return { env: currentEnv, projectId };
+            return this.resolveEnvironmentForConfiguredProject(this.localConfig.projectId, envName);
         }
         if (envName) {
             const current = configManager.getCurrentProject();
@@ -177,4 +190,25 @@ export class LoopressCommand extends Command {
             return { env, projectId: current.id };
         this.error('No environment configured. Run `lps project config` first.');
     }
+    resolveEnvironmentForConfiguredProject(projectId, envName) {
+        const project = configManager.getProject(projectId);
+        if (!project) {
+            this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
+        }
+        const envNames = Object.keys(project.environments);
+        if (envNames.length === 0) {
+            this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
+        }
+        if (envName)
+            return { env: this.pickEnvironment(project, envName), projectId };
+        if (envNames.length === 1) {
+            return { env: project.environments[envNames[0]], projectId };
+        }
+        const current = configManager.getCurrentProject();
+        const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
+        if (!currentEnv) {
+            this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
+        }
+        return { env: currentEnv, projectId };
+    }
 }

package/dist/lib/guard-production-push.d.ts

@@ -0,0 +1,12 @@
+type GuardProductionPushOptions = {
+    dryRun: boolean;
+    error: (message: string) => never;
+    onRefuse?: () => void;
+    siteConfig: {
+        name: string;
+        url: string;
+    };
+    yes: boolean;
+};
+export declare function guardProductionPush(options: GuardProductionPushOptions): Promise<void>;
+export {};

package/dist/lib/guard-production-push.js

@@ -0,0 +1,20 @@
+import { confirm } from '@inquirer/prompts';
+import { isInteractive } from './interactive.js';
+// 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.
+// Shared by PushCommand (lib/push-command.ts, guards a single resource push) and the
+// top-level `lps push` (commands/push.ts, guards once before delegating to 8 sub-commands).
+export async function guardProductionPush(options) {
+    const { dryRun, error, onRefuse, siteConfig, yes } = options;
+    if (dryRun || yes || siteConfig.name.toLowerCase() !== 'production')
+        return;
+    if (!isInteractive()) {
+        onRefuse?.();
+        error('Target environment is "production". Pass --yes to confirm the push in a non-interactive run.');
+    }
+    const isProceed = await confirm({ default: true, message: `Push to production (${siteConfig.url})?` });
+    if (!isProceed) {
+        onRefuse?.();
+        error('Aborted.');
+    }
+}