@loopress/cli 0.28.0 → 0.30.0

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

@@ -8,15 +8,15 @@ export declare class ProjectConfigManager {
         id: string;
     });
     getConfigFilePath(): string;
-    getCurrentEnv(): EnvironmentConfig | null;
     getCurrentProject(): null | (ProjectConfig & {
         id: string;
     });
+    getDefaultEnvironment(projectId: string): EnvironmentConfig | null;
     getEnvironment(projectId: string, envName: string): EnvironmentConfig | null;
     getProject(id: string): null | ProjectConfig;
     isTelemetryDisabled(): boolean;
     listEnvironments(projectId: string): Array<EnvironmentConfig & {
-        isCurrent: boolean;
+        isDefault: boolean;
     }>;
     listProjects(): Array<ProjectConfig & {
         id: string;
@@ -26,7 +26,7 @@ export declare class ProjectConfigManager {
     removeEnvironment(projectId: string, envName: string): void;
     removeProject(id: string): void;
     setConfigDir(configDir: string): void;
-    setCurrent(projectId: string, envName: string): void;
+    setCurrent(projectId: string): void;
     setEnvironment(projectId: string, envName: string, env: EnvironmentConfig): void;
     setEnvironmentApiId(projectId: string, envName: string, apiEnvironmentId: string): void;
     setProject(id: string, project: ProjectConfig): void;

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { LOCAL_ENVIRONMENT_NAME } from '../lib/wp-client.js';
 import { toSlug } from '../utils/to-slug.js';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
@@ -39,15 +40,6 @@ export class ProjectConfigManager {
     getConfigFilePath() {
         return join(this.requireConfigDir(), 'config.json');
     }
-    getCurrentEnv() {
-        const config = this.readConfig();
-        if (!config.currentProject)
-            return null;
-        const project = config.projects[config.currentProject.id];
-        if (!project)
-            return null;
-        return project.environments[config.currentProject.env] ?? null;
-    }
     getCurrentProject() {
         const config = this.readConfig();
         if (!config.currentProject)
@@ -57,6 +49,17 @@ export class ProjectConfigManager {
             return null;
         return { ...project, id: config.currentProject.id };
     }
+    // The environment a command targets without --env: "local" when the project has one (where
+    // you work, so it's the safe default), otherwise its only environment. Null when the project
+    // has several remote ones and no local: the user must say which one with --env, since a
+    // 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;
+    }
     getEnvironment(projectId, envName) {
         const project = this.getProject(projectId);
         if (!project)
@@ -71,14 +74,11 @@ export class ProjectConfigManager {
         return this.readConfig().telemetry?.disabled ?? false;
     }
     listEnvironments(projectId) {
-        const config = this.readConfig();
-        const project = config.projects[projectId];
+        const project = this.getProject(projectId);
         if (!project)
             return [];
-        return Object.values(project.environments).map((env) => ({
-            ...env,
-            isCurrent: config.currentProject?.id === projectId && config.currentProject.env === env.name,
-        }));
+        const defaultEnv = this.getDefaultEnvironment(projectId);
+        return Object.values(project.environments).map((env) => ({ ...env, isDefault: env.name === defaultEnv?.name }));
     }
     listProjects() {
         const config = this.readConfig();
@@ -101,10 +101,6 @@ export class ProjectConfigManager {
         if (!project)
             return;
         Reflect.deleteProperty(project.environments, envName);
-        if (config.currentProject?.id === projectId && config.currentProject.env === envName) {
-            const remaining = Object.keys(project.environments);
-            config.currentProject = remaining.length > 0 ? { env: remaining[0], id: projectId } : null;
-        }
         this.writeConfig(config);
     }
     removeProject(id) {
@@ -112,9 +108,7 @@ export class ProjectConfigManager {
         Reflect.deleteProperty(config.projects, id);
         if (config.currentProject?.id === id) {
             const [nextId] = Object.keys(config.projects);
-            const nextProject = nextId ? config.projects[nextId] : undefined;
-            const [nextEnv] = nextProject ? Object.keys(nextProject.environments) : [];
-            config.currentProject = nextId && nextEnv ? { env: nextEnv, id: nextId } : null;
+            config.currentProject = nextId ? { id: nextId } : null;
         }
         this.writeConfig(config);
     }
@@ -124,11 +118,11 @@ export class ProjectConfigManager {
     setConfigDir(configDir) {
         this.configDir = configDir;
     }
-    setCurrent(projectId, envName) {
+    setCurrent(projectId) {
         const config = this.readConfig();
         if (!Object.hasOwn(config.projects, projectId))
             return;
-        config.currentProject = { env: envName, id: projectId };
+        config.currentProject = { id: projectId };
         this.writeConfig(config);
     }
     setEnvironment(projectId, envName, env) {
@@ -137,7 +131,7 @@ export class ProjectConfigManager {
         if (!project)
             return;
         project.environments[envName] = env;
-        config.currentProject ??= { env: envName, id: projectId };
+        config.currentProject ??= { id: projectId };
         this.writeConfig(config);
     }
     setEnvironmentApiId(projectId, envName, apiEnvironmentId) {
@@ -151,11 +145,7 @@ export class ProjectConfigManager {
     setProject(id, project) {
         const config = this.readConfig();
         config.projects[id] = project;
-        if (!config.currentProject) {
-            const [firstEnv] = Object.keys(project.environments);
-            if (firstEnv)
-                config.currentProject = { env: firstEnv, id };
-        }
+        config.currentProject ??= { id };
         this.writeConfig(config);
     }
     setProjectApiId(id, apiProjectId) {
@@ -203,7 +193,8 @@ export class ProjectConfigManager {
         if (value === null || typeof value !== 'object')
             return null;
         const pointer = value;
-        return typeof pointer.id === 'string' && typeof pointer.env === 'string' ? { env: pointer.env, id: pointer.id } : null;
+        // A legacy `env` field, from when switch also picked the environment, is dropped here.
+        return typeof pointer.id === 'string' ? { id: pointer.id } : null;
     }
     sanitizeProjects(value) {
         if (typeof value !== 'object' || value === null)

package/dist/hooks/finally.d.ts

@@ -1,3 +1,4 @@
-import type { Hook } from '@oclif/core';
+import { type Hook } from '@oclif/core';
 declare const hook: Hook.Finally;
+export declare function dropHttpCause(error: Error): void;
 export default hook;

package/dist/hooks/finally.js

@@ -1,3 +1,5 @@
+import { settings } from '@oclif/core';
+import { RequestError } from 'got';
 import { isTelemetryDisabled, redactArgv, resolveEnvironment, runtimeContext, scrubEvent, SENTRY_DSN, } from '../lib/sentry.js';
 // oclif has no `command_error` hook (checked @oclif/core@4.11.11's hooks.d.ts). `finally`
 // is the closest equivalent: it always runs at the end of the CLI lifecycle and carries
@@ -7,8 +9,15 @@ import { isTelemetryDisabled, redactArgv, resolveEnvironment, runtimeContext, sc
 // It's a heavy module (@opentelemetry deps, import-in-the-middle instrumentation), so loading
 // it eagerly on every command would tax the common case where commands succeed.
 const hook = async function (options) {
-    if (!options.error || isTelemetryDisabled())
+    if (!options.error)
         return;
+    if (!isTelemetryDisabled())
+        await report(this, options);
+    // After the report, so Sentry still gets the whole chain. LPS_DEBUG=1 keeps it on screen too.
+    if (!settings.debug)
+        dropHttpCause(options.error);
+};
+async function report(context, options) {
     try {
         const Sentry = await import('@sentry/node');
         Sentry.init({
@@ -17,11 +26,19 @@ const hook = async function (options) {
             beforeSend: scrubEvent,
             dsn: SENTRY_DSN,
             environment: resolveEnvironment(),
-            release: this.config.version,
+            release: context.config.version,
+            // Sentry 11 collects all of these by default. Headers carry the app password, stack frame
+            // locals can hold it too, and this reports from users' own machines: collect none of it.
+            dataCollection: {
+                cookies: false,
+                httpBodies: [],
+                httpHeaders: false,
+                stackFrameVariables: false,
+                urlQueryParams: false,
+                userInfo: false,
+            },
             // Node defaults `server_name` to os.hostname(), which is often the user's real name
-            // (e.g. "jane-doe-macbook-pro"). sendDefaultPii covers IP addresses and similar, off by
-            // default but set explicitly since this reports from users' own machines.
-            sendDefaultPii: false,
+            // (e.g. "jane-doe-macbook-pro").
             serverName: 'loopress',
         });
         Sentry.captureException(options.error, {
@@ -32,7 +49,21 @@ const hook = async function (options) {
         await Sentry.flush(2000);
     }
     catch (error) {
-        this.debug('Failed to report error to Sentry: %O', error);
+        context.debug('Failed to report error to Sentry: %O', error);
     }
-};
+}
+// WpClient and ApiClient already fold what matters of a got error (status, the server's own
+// reason) into their own message, and keep got's error as `cause` for the helpers that read
+// its response. oclif prints every cause after the message, so without this a clear "Request
+// failed (409) on ...: The active theme is not a block theme" ends with "Caused by: HTTPError:
+// Request failed with status code 409 ... Code: ERR_NON_2XX_3XX_RESPONSE", which is what the
+// user remembers. Other causes (a failed plugin install under its fallback advice) stay.
+export function dropHttpCause(error) {
+    for (let current = error; current instanceof Error; current = current.cause) {
+        if (current.cause instanceof RequestError) {
+            delete current.cause;
+            return;
+        }
+    }
+}
 export default hook;

package/dist/lib/api-client.js

@@ -1,4 +1,5 @@
 import got from 'got';
+import { withSpinner } from './spinner.js';
 import { REQUEST_TIMEOUT_MS } from './wp-client.js';
 export const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
 /**
@@ -29,7 +30,7 @@ export class ApiClient {
     }
     async request(method, path, json) {
         try {
-            const response = await this.client(path, { json, method });
+            const response = await withSpinner('Waiting for the Loopress API', async () => this.client(path, { json, method }));
             return (response.body ? JSON.parse(response.body) : undefined);
         }
         catch (error) {

package/dist/lib/app-build.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+import { withSpinner } from './spinner.js';
 // The package managers `lps app push` may spawn. An allowlist, not the raw `packageManager`
 // field: the name ends up as a process to run.
 const PACKAGE_MANAGERS = ['bun', 'npm', 'pnpm', 'yarn'];
@@ -43,7 +44,7 @@ export async function buildApp(appDir, onStart) {
     const pm = detectPackageManager(appDir, pkg.packageManager);
     const command = `${pm} run build`;
     onStart?.(command);
-    const { code, output } = await new Promise((resolve, reject) => {
+    const build = new Promise((resolve, reject) => {
         // Windows resolves `npm` to `npm.cmd`, which only a shell finds. `pm` comes from the
         // allowlist above, so the shell never sees user input.
         const child = spawn(pm, ['run', 'build'], { cwd: appDir, shell: process.platform === 'win32' });
@@ -58,6 +59,7 @@ export async function buildApp(appDir, onStart) {
             resolve({ code: exitCode, output: out });
         });
     });
+    const { code, output } = await withSpinner(`Running ${command}`, async () => build);
     if (code !== 0) {
         const tail = output.trimEnd().split('\n').slice(-OUTPUT_TAIL_LINES).join('\n');
         const hint = existsSync(join(appDir, 'node_modules'))

package/dist/lib/app-manifest.js

@@ -22,7 +22,7 @@ export function isAllowedAsset(relPath) {
 // 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 walkFiles(distDir)).sort((a, b) => a.localeCompare(b));
+    const relPaths = (await walkFiles(distDir)).toSorted((a, b) => a.localeCompare(b));
     const files = [];
     for (const path of relPaths) {
         if (!isAllowedAsset(path)) {
@@ -37,7 +37,7 @@ export async function buildFileList(distDir) {
 // 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))) {
+    for (const file of files.toSorted((a, b) => a.path.localeCompare(b.path))) {
         digest.update(`${file.path}:${file.sha256}\n`);
     }
     return digest.digest('hex').slice(0, 12);

package/dist/lib/base.d.ts

@@ -14,6 +14,7 @@ export declare abstract class LoopressCommand extends Command {
     };
     protected dryRun: boolean;
     protected localConfig: LoopressLocalConfig;
+    protected productionConfirmed: boolean;
     protected projectId: string;
     protected siteConfig: EnvironmentConfig;
     protected yes: boolean;
@@ -38,10 +39,9 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveHooksPath(override?: string): string;
     protected resolveMenuPath(override?: string): string;
     protected resolveOptionsPath(override?: string): string;
-    protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     protected resolveThemeStylesPath(override?: string): string;
+    protected warnRemovedSeoModule(): void;
     private pickEnvironment;
     private resolveEnvironment;
-    private resolveEnvironmentForConfiguredProject;
 }

package/dist/lib/base.js

@@ -1,6 +1,7 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
+import { existsSync } from 'node:fs';
 import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
@@ -9,13 +10,14 @@ import { pluralize } from '../utils/pluralize.js';
 import { resolveResourceDir } from '../utils/resource-dirs.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
+import { withoutSpinner } from './spinner.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.
+    // On every subclass without opt-in. Without it, commands target the "local" environment, so
+    // reaching a remote site is always spelled out in the command itself.
     static baseFlags = {
         env: Flags.string({
-            description: 'Target environment by name, overriding the globally active one (lps project switch)',
+            description: 'Target environment by name (default: "local", or the project\'s only environment)',
         }),
     };
     static dryRunFlag = {
@@ -26,6 +28,8 @@ export class LoopressCommand extends Command {
     };
     dryRun = false;
     localConfig = {};
+    // Set by PushCommand's hidden --production-confirmed, see there.
+    productionConfirmed = false;
     projectId;
     siteConfig;
     yes = false;
@@ -54,6 +58,7 @@ export class LoopressCommand extends Command {
         }));
         this.dryRun = Boolean(flags['dry-run']);
         this.yes = Boolean(flags.yes);
+        this.productionConfirmed = Boolean(flags['production-confirmed']);
         this.localConfig = await readLocalConfig();
         const resolved = this.resolveEnvironment(flags.env);
         this.siteConfig = resolved.env;
@@ -104,13 +109,15 @@ export class LoopressCommand extends Command {
         }
         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 withoutSpinner(async () => {
+            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);
     }
@@ -162,15 +169,19 @@ export class LoopressCommand extends Command {
     resolveOptionsPath(override) {
         return resolveResourceDir('options', this.localConfig, override);
     }
-    resolveSeoPath(override) {
-        return resolveResourceDir('seo', this.localConfig, override);
-    }
     resolveSnippetsPath(override) {
         return resolveResourceDir('snippets', this.localConfig, override);
     }
     resolveThemeStylesPath(override) {
         return resolveResourceDir('themeStyles', this.localConfig, override);
     }
+    // `lps seo` was removed: a leftover seo/ folder or seoDir key would otherwise be silently
+    // ignored by `lps pull` / `lps push`. Remove once projects have had a release to migrate.
+    warnRemovedSeoModule() {
+        if (!('seoDir' in this.localConfig) && !existsSync(join(this.rootDir, 'seo')))
+            return;
+        this.warn('The SEO module was removed: seo/ is no longer pulled or pushed. Track SEO plugin settings with `lps option add rank-math-options-titles` (or `wpseo_titles`), then delete seo/ and any seoDir key from loopress.json.');
+    }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];
         if (!env) {
@@ -178,24 +189,12 @@ export class LoopressCommand extends Command {
         }
         return env;
     }
+    // Order: --env, then the project's default (see getDefaultEnvironment). The project comes from
+    // loopress.json when pinned, from `lps project switch` otherwise.
     resolveEnvironment(envName) {
-        if (this.localConfig.projectId) {
-            return this.resolveEnvironmentForConfiguredProject(this.localConfig.projectId, envName);
-        }
-        if (envName) {
-            const current = configManager.getCurrentProject();
-            if (!current) {
-                this.error('No project configured. Run `lps project config` first.');
-            }
-            return { env: this.pickEnvironment(current, envName), projectId: current.id };
-        }
-        const env = configManager.getCurrentEnv();
-        const current = configManager.getCurrentProject();
-        if (env && current)
-            return { env, projectId: current.id };
-        this.error('No environment configured. Run `lps project config` first.');
-    }
-    resolveEnvironmentForConfiguredProject(projectId, envName) {
+        const projectId = this.localConfig.projectId ?? configManager.getCurrentProject()?.id;
+        if (!projectId)
+            this.error('No project configured. Run `lps project config` first.');
         const project = configManager.getProject(projectId);
         if (!project) {
             this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
@@ -206,14 +205,10 @@ export class LoopressCommand extends Command {
         }
         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.`);
+        const env = configManager.getDefaultEnvironment(projectId);
+        if (!env) {
+            this.error(`Project "${project.name}" has no "local" environment, pass --env to pick one. Available: ${envNames.join(', ')}`);
         }
-        return { env: currentEnv, projectId };
+        return { env, projectId };
     }
 }

package/dist/lib/declared-type-command.d.ts

@@ -0,0 +1,35 @@
+import { type DeclaredTypeSpec, type RegisteredItem } from '../utils/declared-type-format.js';
+import { LoopressCommand } from './base.js';
+import { type CommandClass } from './php-files-command.js';
+import { PushCommand } from './push-command.js';
+type PushResult = {
+    path: string;
+    pushed: string[];
+    status: 'dry-run' | 'success';
+};
+type PullResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+};
+type RmResult = {
+    removed: boolean;
+    slug: string;
+    status: 'aborted' | 'dry-run' | 'success';
+};
+export type DeclaredPushCommand = Omit<PushCommand, 'run'> & {
+    run(): Promise<PushResult>;
+};
+export declare function declaredPushCommand(spec: DeclaredTypeSpec, description: string): CommandClass<DeclaredPushCommand>;
+export type DeclaredPullCommand = Omit<LoopressCommand, 'run'> & {
+    run(): Promise<PullResult>;
+};
+export declare function declaredPullCommand(spec: DeclaredTypeSpec, description: string): CommandClass<DeclaredPullCommand>;
+export type DeclaredListCommand = Omit<LoopressCommand, 'run'> & {
+    run(): Promise<RegisteredItem[]>;
+};
+export declare function declaredListCommand(spec: DeclaredTypeSpec, description: string, countLabel: (count: number) => string): CommandClass<DeclaredListCommand>;
+export type DeclaredRmCommand = Omit<LoopressCommand, 'run'> & {
+    run(): Promise<RmResult>;
+};
+export declare function declaredRmCommand(spec: DeclaredTypeSpec, description: string, keptNote: string): CommandClass<DeclaredRmCommand>;
+export {};