@loopress/cli 0.28.0 → 0.30.0

package/dist/commands/meta/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { META_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(META_SPEC, 'Stop registering the Loopress meta keys of one post type (its meta/<post-type>.json file) on WordPress. Their values are kept in the database.', "Their values are kept in the database, hidden until it's pushed again.");

package/dist/commands/meta/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/meta/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('meta', {
+    description: 'Restore post meta keys to a snapshot taken automatically before an earlier `lps meta push`',
+    pathNoun: 'meta directory',
+});

package/dist/commands/option/list.js

@@ -1,6 +1,7 @@
 import { Flags, ux } from '@oclif/core';
 import ttyTable from 'tty-table';
 import { LoopressCommand } from '../../lib/base.js';
+import { withSpinner } from '../../lib/spinner.js';
 import { OPTIONS_ENDPOINT } from '../../utils/option-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 // Same green/yellow pairing drives both SOURCE? and PLUGIN, so a row's whole "where did this come
@@ -127,14 +128,7 @@ export default class List extends LoopressCommand {
         // Every call scans active plugins' own PHP source for names the naming guess missed (not
         // opt-in, roughly 1-3s on a real site once vendor/tests/languages are pruned from the scan;
         // see OptionsService::listOptionNames() server-side), hence the spinner unconditionally.
-        ux.action.start('Fetching and verifying options');
-        let options;
-        try {
-            options = await this.wp.get(OPTIONS_ENDPOINT);
-        }
-        finally {
-            ux.action.stop();
-        }
+        let options = await withSpinner('Fetching and verifying options', async () => this.wp.get(OPTIONS_ENDPOINT));
         if (flags['no-core'])
             options = options.filter((option) => !option.core);
         if (options.length === 0) {

package/dist/commands/option/pull.js

@@ -56,19 +56,19 @@ export default class Pull extends LoopressCommand {
     }
     // Returns the refreshed option (and writes it to disk), or null when the tracked name is a
     // 404 on this environment: absent, not a failure (see the orphan reconciliation in run()).
-    // readonly is a local policy flag with no WordPress counterpart, always preserved from the
-    // existing file rather than overwritten by the pulled value.
+    // readonly and refs are local declarations with no WordPress counterpart, always preserved
+    // from the existing file rather than overwritten by the pulled value.
     async pullOption(dir, option) {
         let remote;
         try {
-            remote = await this.wp.get(optionEndpoint(option.name));
+            remote = await this.wp.get(optionEndpoint(option.name, option.refs));
         }
         catch (error) {
             if (isNotFoundError(error))
                 return null;
             throw error;
         }
-        const local = { ...remote, readonly: option.readonly };
+        const local = { ...remote, readonly: option.readonly, refs: option.refs };
         await writeFile(join(dir, optionFileName(option.name)), JSON.stringify(local, null, 2) + '\n');
         return local;
     }

package/dist/commands/option/push.js

@@ -78,6 +78,8 @@ export default class Push extends PushCommand {
             // create): falls back to today's unconditional write, same as before this existed.
             const expectedRevision = await this.currentRevision(option.name);
             const body = { autoload: option.autoload, value: option.value };
+            if (option.refs)
+                body.refs = option.refs;
             if (expectedRevision !== undefined)
                 body.expectedRevision = expectedRevision;
             await this.wp.put(optionEndpoint(option.name), body);

package/dist/commands/page/push.js

@@ -1,5 +1,6 @@
 import { Args } from '@oclif/core';
 import { PushCommand } from '../../lib/push-command.js';
+import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { formatPageProblems, frontPageNote, PAGES_ENDPOINT, readLocalPages } from '../../utils/page-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { resolveResourceDir } from '../../utils/resource-dirs.js';
@@ -28,6 +29,8 @@ export default class Push extends PushCommand {
             this.error(`No page "${args.slug}" in ${path} (expected ${args.slug}.html).`);
         }
         this.log(`Found ${pluralize(selected.length, 'page')} to push`);
+        if (this.dryRun)
+            await this.previewRemote(getResourceStateProvider('page'), path);
         const pushed = [];
         await this.runPushTasks(selected, (page) => page.slug, async (page, task) => {
             await this.pushPage(page, task);

package/dist/commands/pattern/diff.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/diff-command.js").DiffCommand;
+export default _default;

package/dist/commands/pattern/diff.js

@@ -0,0 +1,5 @@
+import { resourceDiffCommand } from '../../lib/diff-command.js';
+export default resourceDiffCommand('pattern', {
+    description: 'Show what differs in block patterns between your local patterns/ files and a WordPress environment, or between two environments',
+    pathNoun: 'patterns directory',
+});

package/dist/commands/pattern/list.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredListCommand>;
+export default _default;

package/dist/commands/pattern/list.js

@@ -0,0 +1,3 @@
+import { declaredListCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredListCommand(PATTERN_SPEC, 'List the block patterns registered on WordPress by Loopress, the theme and plugins (not WordPress core). Only Loopress ones are pulled and pushed.', () => '');

package/dist/commands/pattern/pull.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPullCommand>;
+export default _default;

package/dist/commands/pattern/pull.js

@@ -0,0 +1,4 @@
+import { declaredPullCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPullCommand(PATTERN_SPEC, 'Pull the block patterns Loopress manages on WordPress into patterns/<slug>.html files. ' +
+    'Patterns registered by the theme or a plugin are never pulled, see `lps pattern list`.');

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredPushCommand>;
+export default _default;

package/dist/commands/pattern/push.js

@@ -0,0 +1,4 @@
+import { declaredPushCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredPushCommand(PATTERN_SPEC, 'Push local block patterns (patterns/<slug>.html, block markup under a title/categories header) to WordPress, ' +
+    'registered as loopress/<slug>. Create or update only, never deletes a pattern (use `lps pattern rm`).');

package/dist/commands/pattern/rm.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../lib/php-files-command.js").CommandClass<import("../../lib/declared-type-command.js").DeclaredRmCommand>;
+export default _default;

package/dist/commands/pattern/rm.js

@@ -0,0 +1,3 @@
+import { declaredRmCommand } from '../../lib/declared-type-command.js';
+import { PATTERN_SPEC } from '../../utils/declared-type-format.js';
+export default declaredRmCommand(PATTERN_SPEC, 'Stop registering a Loopress block pattern on WordPress. A wp:pattern reference to it renders nothing, copies already inserted in posts stay.', 'A wp:pattern reference to it renders nothing until it is pushed again, copies already inserted in posts stay.');

package/dist/commands/pattern/rollback.d.ts

@@ -0,0 +1,2 @@
+declare const _default: typeof import("../../lib/base.js").LoopressCommand;
+export default _default;

package/dist/commands/pattern/rollback.js

@@ -0,0 +1,5 @@
+import { resourceRollbackCommand } from '../../lib/rollback-command.js';
+export default resourceRollbackCommand('pattern', {
+    description: 'Restore block patterns to a snapshot taken automatically before an earlier `lps pattern push`',
+    pathNoun: 'patterns directory',
+});

package/dist/commands/plugin/audit.js

@@ -1,5 +1,6 @@
 import got from 'got';
 import { LoopressCommand } from '../../lib/base.js';
+import { withSpinner } from '../../lib/spinner.js';
 import { pinVersion } from '../../types/plugin.js';
 import { compareVersions } from '../../utils/version.js';
 const WPVULN_BASE = 'https://www.wpvulnerability.net/plugin';
@@ -19,7 +20,7 @@ export default class Audit extends LoopressCommand {
         const advisories = [];
         const health = [];
         for (const slug of slugs) {
-            const found = await this.auditOne(slug, pinVersion(manifest[slug]));
+            const found = await withSpinner(`Auditing ${slug}`, async () => this.auditOne(slug, pinVersion(manifest[slug])));
             advisories.push(...found.advisories);
             health.push(...found.health);
         }

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

@@ -4,14 +4,18 @@ import { type MergeResult } from '../../utils/plugins.js';
 type PullResult = MergeResult & {
     skipped?: ComposerPullResult['skipped'];
     status: 'dry-run' | 'success';
+    untracked: string[];
 };
 export default class Pull extends LoopressCommand {
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        plugin: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PullResult>;
+    private selectPlugins;
 }
 export {};

package/dist/commands/plugin/pull.js

@@ -1,36 +1,60 @@
+import { checkbox } from '@inquirer/prompts';
+import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
-import { pullIntoComposerJson } from '../../utils/composer.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { getComposerManagedSlugs, NOT_ON_WORDPRESS_ORG, pullIntoComposerJson, } from '../../utils/composer.js';
 import { writeLocalConfig } from '../../utils/loopress-config.js';
 import { mergePluginManifest, parseInstalledPlugins } from '../../utils/plugins.js';
 export default class Pull extends LoopressCommand {
-    static description = 'Pull installed plugins from WordPress into loopress.json, pinned to their live versions';
+    static description = 'Pull installed plugins from WordPress into loopress.json (or composer.json), pinned to their live versions. ' +
+        'Plugins already tracked are refreshed; new ones are offered as a list to tick, so plugins that only belong ' +
+        'on this environment (cache, security, backups) stay out of the project.';
     static enableJsonFlag = true;
-    static examples = ['$ lps plugin pull', '$ lps plugin pull --dry-run'];
+    static examples = ['$ lps plugin pull', '$ lps plugin pull --env production --plugin query-monitor'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+        plugin: Flags.string({
+            description: 'Start tracking this installed plugin too, without asking (repeatable)',
+            multiple: true,
+        }),
     };
     async run() {
+        const { flags } = await this.parse(Pull);
         const { url } = this.siteConfig;
         this.log(`Pulling plugins from ${url}`);
         const raw = await this.wp.get('wp/v2/plugins');
-        const installed = parseInstalledPlugins(raw);
+        const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
+        const composerJson = existsSync(composerJsonPath)
+            ? JSON.parse(await readFile(composerJsonPath, 'utf8'))
+            : undefined;
+        const declared = new Set(composerJson ? getComposerManagedSlugs(composerJson) : Object.keys(this.localConfig.plugins ?? {}));
+        const all = parseInstalledPlugins(raw);
+        const selected = await this.selectPlugins(all, declared, flags.plugin ?? [], flags.yes);
+        const installed = all.filter((p) => selected.has(p.slug));
+        const untracked = all.filter((p) => !selected.has(p.slug)).map((p) => p.slug);
+        if (untracked.length > 0) {
+            this.log(`  - Not tracked: ${untracked.join(', ')} (add one with \`lps plugin pull --plugin <slug>\`)`);
+        }
         // Pin every plugin to the version actually running on the site, and record the inactive ones
         // as such so a later `plugin push` doesn't switch them on. A later `plugin push` installs
         // exactly this set via Composer + WPackagist; drift only surfaces when the pinned version and
         // the live version disagree.
         const versions = Object.fromEntries(installed.map((p) => [p.slug, p.version]));
-        const pins = Object.fromEntries(installed.map((p) => [p.slug, p.active ? p.version : { active: false, version: p.version }]));
         // A composer.json is authoritative over loopress.json: pin the live versions there instead.
-        const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
-        if (existsSync(composerJsonPath)) {
+        if (composerJson) {
             const result = await pullIntoComposerJson(composerJsonPath, 'plugin', versions, {
                 dryRun: this.dryRun,
                 log: this.log.bind(this),
             });
-            return { ...result, status: this.dryRun ? 'dry-run' : 'success' };
+            // Ticked, but Composer can't install it (premium or custom): still not tracked by the project.
+            const notInstallable = result.skipped.filter((s) => s.reason === NOT_ON_WORDPRESS_ORG).map((s) => s.slug);
+            return { ...result, status: this.dryRun ? 'dry-run' : 'success', untracked: [...untracked, ...notInstallable] };
         }
+        const pins = Object.fromEntries(installed.map((p) => [p.slug, p.active ? p.version : { active: false, version: p.version }]));
         const { added, merged, updated } = mergePluginManifest(this.localConfig.plugins ?? {}, pins);
         if (this.dryRun) {
             this.log(`[dry-run] Would write ${Object.keys(merged).length} plugins to loopress.json`);
@@ -38,7 +62,7 @@ export default class Pull extends LoopressCommand {
                 this.log(`  + ${added.join(', ')}`);
             for (const u of updated)
                 this.log(`  ~ ${u.slug} (${u.from} → ${u.to})`);
-            return { added, merged, status: 'dry-run', updated };
+            return { added, merged, status: 'dry-run', untracked, updated };
         }
         await writeLocalConfig({ ...this.localConfig, plugins: merged });
         this.log(`Wrote ${Object.keys(merged).length} plugins to loopress.json`);
@@ -46,6 +70,28 @@ export default class Pull extends LoopressCommand {
             this.log(`  + Added: ${added.join(', ')}`);
         for (const u of updated)
             this.log(`  ~ Updated: ${u.slug} ${u.from} → ${u.to}`);
-        return { added, merged, status: 'success', updated };
+        return { added, merged, status: 'success', untracked, updated };
+    }
+    // Plugins already tracked are always refreshed, plus any --plugin. Every other installed plugin
+    // is offered unticked, so a second pull from production never brings Wordfence back on its
+    // own. With nobody to ask (--yes, --json, CI, the MCP server), only those two sets count:
+    // "track everything" would bring the same problem back silently.
+    async selectPlugins(installed, declared, requested, yes) {
+        const slugs = new Set(installed.map((p) => p.slug));
+        for (const slug of requested) {
+            if (!slugs.has(slug))
+                this.warn(`--plugin ${slug}: not installed on this environment, skipped.`);
+        }
+        const selected = new Set([...slugs].filter((slug) => declared.has(slug) || requested.includes(slug)));
+        const candidates = installed.filter((p) => !selected.has(p.slug));
+        if (yes || candidates.length === 0 || this.jsonEnabled() || !isInteractive())
+            return selected;
+        const picked = await checkbox({
+            choices: candidates.map((p) => ({ name: `${p.slug} ${p.version}${p.active ? '' : ' (inactive)'}`, value: p.slug })),
+            message: 'Which of these plugins should the project track? Leave the ones that only belong on this environment unticked.',
+        });
+        for (const slug of picked)
+            selected.add(slug);
+        return selected;
     }
 }

package/dist/commands/plugin/push.js

@@ -4,9 +4,9 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { confirmUninstall } from '../../lib/interactive.js';
 import { PushCommand } from '../../lib/push-command.js';
-import { isNotFoundError } from '../../lib/wp-client.js';
+import { isLocalEnvironment, isNotFoundError } from '../../lib/wp-client.js';
 import { pinActive, pinVersion, pinVersions, } from '../../types/plugin.js';
-import { toIntent, wpackagistRequire } from '../../utils/composer.js';
+import { requireToInstall, toIntent, wpackagistRequire } from '../../utils/composer.js';
 import { isDowngrade, parseCollisions, SYNC_TIMEOUT_MS, } from '../../utils/plugin-sync.js';
 import { diffPlugins, lockedWpackagistSlugs, parseInstalledPlugins } from '../../utils/plugins.js';
 import { isExactVersion } from '../../utils/version.js';
@@ -178,11 +178,12 @@ export default class Push extends PushCommand {
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         if (existsSync(composerJsonPath)) {
             const composerJson = JSON.parse(await readFile(composerJsonPath, 'utf8'));
-            const manifest = wpackagistRequire(composerJson, 'plugin');
+            const includeDev = isLocalEnvironment(this.siteConfig.name);
+            const manifest = wpackagistRequire(composerJson, 'plugin', includeDev);
             if (Object.keys(manifest).length === 0) {
                 this.error('No wpackagist-plugin/* package in composer.json. Run `lps plugin pull` first, or `lps composer push` to push it as is.');
             }
-            const require = composerJson.require ?? {};
+            const require = requireToInstall(composerJson, includeDev);
             return { file: 'composer.json', intent: toIntent(require), manifest, packageCount: Object.keys(require).length };
         }
         if (activate) {

package/dist/commands/project/config.d.ts

@@ -7,4 +7,5 @@ export default class Config extends Command {
     private promptManualCredentials;
     private resolveCredentials;
     private resolveProject;
+    private sweepLeftoverTempAdmins;
 }

package/dist/commands/project/config.js

@@ -4,9 +4,12 @@ import { configManager } from '../../config/project-config.manager.js';
 import { bootstrapLoopressFull } from '../../lib/bootstrap-full-install.js';
 import { isInteractive } from '../../lib/interactive.js';
 import { isLoopressFullActive } from '../../lib/plugin-detection.js';
+import { withSpinner } from '../../lib/spinner.js';
+import { sweepTempAdmins } from '../../lib/temp-admin.js';
 import { authorizeWithBrowser } from '../../lib/wp-authorize-flow.js';
 import { isLocalEnvironment, WpClient } from '../../lib/wp-client.js';
 import { diagnoseWpSite } from '../../lib/wp-site-diagnostic.js';
+import { pluralize } from '../../utils/pluralize.js';
 const NEW_PROJECT = '__new__';
 const AUTH_BROWSER = 'browser';
 const AUTH_MANUAL = 'manual';
@@ -96,6 +99,10 @@ export default class Config extends Command {
         if (!token)
             return; // env was just built with one a few lines up; guard only narrows the type
         const wp = new WpClient(url, token, name);
+        // Before the "already active" early return: an install killed mid-way (SIGKILL, power loss)
+        // may have activated Full and still left its temp admin behind, and re-running this command
+        // is the documented fix for both.
+        await this.sweepLeftoverTempAdmins(wp);
         // A detection failure (network hiccup, plugins REST disabled) is treated as "assume it's
         // there" rather than surprising the user with an account-creating prompt they didn't ask
         // for; `lps project config` can simply be re-run if it genuinely isn't installed.
@@ -109,7 +116,9 @@ export default class Config extends Command {
         if (!isProceed)
             return;
         try {
-            await bootstrapLoopressFull(wp, url, (message) => { this.log(message); });
+            await withSpinner('Installing Loopress Full', async () => bootstrapLoopressFull(wp, url, (message) => {
+                this.log(message);
+            }));
         }
         catch (error) {
             this.warn(error.message);
@@ -181,4 +190,14 @@ export default class Config extends Command {
         });
         return { projectId: configManager.createProjectId(projectName.trim()), projectName: projectName.trim() };
     }
+    async sweepLeftoverTempAdmins(wp) {
+        try {
+            const removed = await sweepTempAdmins(wp);
+            if (removed.length > 0)
+                this.log(`✓ Removed ${pluralize(removed.length, 'leftover temporary admin account')}: ${removed.join(', ')}`);
+        }
+        catch (error) {
+            this.warn(error.message);
+        }
+    }
 }

package/dist/commands/project/list.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
 type EnvironmentInfo = {
-    isCurrent: boolean;
+    isDefault: boolean;
     name: string;
     url: string;
 };

package/dist/commands/project/list.js

@@ -14,15 +14,15 @@ export default class List extends Command {
         }
         return projects.map((project) => this.logProject(project));
     }
-    // Only name/url/isCurrent are surfaced, deliberately: EnvironmentConfig also carries the
+    // Only name/url/isDefault are surfaced, deliberately: EnvironmentConfig also carries the
     // WordPress application password token, which must never end up in --json output.
     logEnvironment(env) {
-        const envMarker = c(env.isCurrent ? 'cyan' : 'dim', '·');
-        const envName = c(env.isCurrent ? 'cyan' : 'dim', env.name.padEnd(15));
+        const envMarker = c(env.isDefault ? 'cyan' : 'dim', '·');
+        const envName = c(env.isDefault ? 'cyan' : 'dim', env.name.padEnd(15));
         const envUrl = c('dim', env.url);
-        const activeTag = env.isCurrent ? ` ${c('cyan', '←')}` : '';
-        this.log(`  ${envMarker} ${envName} ${envUrl}${activeTag}`);
-        return { isCurrent: env.isCurrent, name: env.name, url: env.url };
+        const defaultTag = env.isDefault ? ` ${c('cyan', '[default]')}` : '';
+        this.log(`  ${envMarker} ${envName} ${envUrl}${defaultTag}`);
+        return { isDefault: env.isDefault, name: env.name, url: env.url };
     }
     logProject(project) {
         const marker = project.isCurrent ? c('green', '●') : c('dim', '○');

package/dist/commands/project/pull.js

@@ -3,6 +3,7 @@ import { Listr } from 'listr2';
 import { authManager } from '../../config/auth.manager.js';
 import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
+import { withoutSpinner } from '../../lib/spinner.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Pull extends Command {
     static description = 'Pull projects and environments from your Loopress account that are not configured locally yet';
@@ -23,14 +24,16 @@ export default class Pull extends Command {
         let projectCount = 0;
         let environmentCount = 0;
         if (newApiProjects.length > 0) {
-            await new Listr(newApiProjects.map((apiProject) => ({
-                task: (_ctx, task) => {
-                    this.pullProject(apiProject, task);
-                    projectCount++;
-                    environmentCount += apiProject.environments.length;
-                },
-                title: `Pull project "${apiProject.name}" from the API`,
-            })), { concurrent: false, exitOnError: false }).run();
+            await withoutSpinner(async () => {
+                await new Listr(newApiProjects.map((apiProject) => ({
+                    task: (_ctx, task) => {
+                        this.pullProject(apiProject, task);
+                        projectCount++;
+                        environmentCount += apiProject.environments.length;
+                    },
+                    title: `Pull project "${apiProject.name}" from the API`,
+                })), { concurrent: false, exitOnError: false }).run();
+            });
         }
         this.log(`\n✓ Pulled ${pluralize(projectCount, 'project')}, ${pluralize(environmentCount, 'environment')} from your Loopress account`);
     }

package/dist/commands/project/push.js

@@ -6,6 +6,7 @@ import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 import { LoopressCommand } from '../../lib/base.js';
 import { isInteractive } from '../../lib/interactive.js';
+import { withoutSpinner } from '../../lib/spinner.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends Command {
@@ -66,15 +67,17 @@ export default class Push extends Command {
         if (envsNeedingWork.length === 0)
             return 0;
         let count = 0;
-        await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
-            task: async (_ctx, task) => {
-                await this.applyEnvironment(api, apiProjectId, envPlan, task);
-                count++;
-            },
-            title: envPlan.action === 'create'
-                ? `Create environment "${envPlan.env.name}" on "${projectName}"`
-                : `Link environment "${envPlan.env.name}" on "${projectName}"`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await withoutSpinner(async () => {
+            await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
+                task: async (_ctx, task) => {
+                    await this.applyEnvironment(api, apiProjectId, envPlan, task);
+                    count++;
+                },
+                title: envPlan.action === 'create'
+                    ? `Create environment "${envPlan.env.name}" on "${projectName}"`
+                    : `Link environment "${envPlan.env.name}" on "${projectName}"`,
+            })), { concurrent: false, exitOnError: false }).run();
+        });
         return count;
     }
     async applyProject(api, plan, task) {
@@ -101,15 +104,17 @@ export default class Push extends Command {
         if (projectsNeedingWork.length === 0)
             return 0;
         let count = 0;
-        await new Listr(projectsNeedingWork.map((plan) => ({
-            task: async (_ctx, task) => {
-                await this.applyProject(api, plan, task);
-                count++;
-            },
-            title: plan.action === 'create'
-                ? `Create project "${plan.project.name}" on the API`
-                : `Link project "${plan.project.name}" to the API`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await withoutSpinner(async () => {
+            await new Listr(projectsNeedingWork.map((plan) => ({
+                task: async (_ctx, task) => {
+                    await this.applyProject(api, plan, task);
+                    count++;
+                },
+                title: plan.action === 'create'
+                    ? `Create project "${plan.project.name}" on the API`
+                    : `Link project "${plan.project.name}" to the API`,
+            })), { concurrent: false, exitOnError: false }).run();
+        });
         return count;
     }
     collectEnvsNeedingWork(projectPlans, envPlansByProject) {

package/dist/commands/project/remove.js

@@ -24,7 +24,7 @@ export default class Remove extends Command {
             const envChoices = configManager.listEnvironments(project.id).map((env) => {
                 targets.push({ env: env.name, kind: 'env', projectId: project.id, projectName: project.name });
                 return {
-                    name: `    ${env.name.padEnd(20)} ${env.url}${env.isCurrent ? ' [current]' : ''}`,
+                    name: `    ${env.name.padEnd(20)} ${env.url}`,
                     value: String(targets.length - 1),
                 };
             });

package/dist/commands/project/switch.d.ts

@@ -3,5 +3,4 @@ export default class Switch extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
-    private resolveSelection;
 }

package/dist/commands/project/switch.js

@@ -1,9 +1,8 @@
-import { select, Separator } from '@inquirer/prompts';
-import { Command, ux } from '@oclif/core';
+import { select } from '@inquirer/prompts';
+import { Command } from '@oclif/core';
 import { configManager } from '../../config/project-config.manager.js';
-const c = ux.colorize;
 export default class Switch extends Command {
-    static description = 'Switch the active project and environment';
+    static description = 'Switch the active project (pass --env to target a non-local environment)';
     static examples = ['$ lps project switch'];
     async run() {
         await this.parse(Switch);
@@ -11,37 +10,18 @@ export default class Switch extends Command {
         if (projects.length === 0) {
             this.error('No projects configured. Run `lps project config` first.');
         }
-        const { envName, projectId, projectName } = await this.resolveSelection(projects);
-        configManager.setCurrent(projectId, envName);
-        this.log(`✓ Switched to "${projectName}/${envName}"`);
-    }
-    async resolveSelection(projects) {
-        const groups = projects
-            .map((project) => ({ envs: configManager.listEnvironments(project.id), project }))
-            .filter(({ envs }) => envs.length > 0);
-        if (groups.length === 0) {
-            this.error('No environments configured. Run `lps project config` first.');
-        }
-        const entries = groups.flatMap(({ envs, project }) => envs.map((env) => ({ env, project })));
-        if (entries.length === 1) {
-            const { env, project } = entries[0];
-            return { envName: env.name, projectId: project.id, projectName: project.name };
-        }
-        const choices = groups.flatMap(({ envs, project }) => [
-            new Separator(c(project.isCurrent ? 'green' : 'dim', `─── ${project.name} ───`)),
-            ...envs.map((env) => ({
-                name: `${env.name.padEnd(20)} ${env.url}${env.isCurrent ? ' [current]' : ''}`,
-                value: `${project.id}::${env.name}`,
-            })),
-        ]);
-        const current = entries.find(({ env }) => env.isCurrent);
-        const chosen = await select({
-            choices,
-            default: current && `${current.project.id}::${current.env.name}`,
-            message: 'Select project / environment',
-        });
-        const [projectId, envName] = chosen.split('::', 2);
-        const { project } = groups.find((group) => group.project.id === projectId);
-        return { envName, projectId, projectName: project.name };
+        const projectId = projects.length === 1
+            ? projects[0].id
+            : await select({
+                choices: projects.map((project) => ({
+                    name: `${project.name}${project.isCurrent ? ' [current]' : ''}`,
+                    value: project.id,
+                })),
+                default: projects.find((project) => project.isCurrent)?.id,
+                message: 'Select project',
+            });
+        configManager.setCurrent(projectId);
+        const project = projects.find((candidate) => candidate.id === projectId);
+        this.log(`✓ Switched to "${project.name}"`);
     }
 }