@loopress/cli 0.28.0 → 0.29.0

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

@@ -1,15 +1,23 @@
 import { LoopressCommand } from '../../lib/base.js';
+import { type AcfObjectType } from '../../utils/acf-format.js';
+type AcfPullResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+    types: AcfObjectType[];
+};
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         type: 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<void>;
+    run(): Promise<AcfPullResult>;
     private pullType;
 }
+export {};

package/dist/commands/acf/pull.js

@@ -9,6 +9,7 @@ export default class Pull extends LoopressCommand {
         path: Args.string({ description: 'Path to ACF directory (overrides project config)' }),
     };
     static description = 'Pull ACF field groups, post types, taxonomies, and options pages from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps acf pull', '$ lps acf pull --type field-groups'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -25,6 +26,7 @@ export default class Pull extends LoopressCommand {
         for (const type of types) {
             await this.pullType(type, path);
         }
+        return { path, status: this.dryRun ? 'dry-run' : 'success', types };
     }
     async pullType(type, basePath) {
         const dir = join(basePath, type);

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

@@ -1,18 +1,26 @@
 import { PushCommand } from '../../lib/push-command.js';
+import { type AcfObjectType } from '../../utils/acf-format.js';
+type AcfPushResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+    types: AcfObjectType[];
+};
 export default class Push extends PushCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         type: 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<void>;
+    run(): Promise<AcfPushResult>;
     private currentRevision;
     private loadObjects;
     private pushObject;
     private pushType;
 }
+export {};

package/dist/commands/acf/push.js

@@ -11,6 +11,7 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to ACF directory (overrides project config)' }),
     };
     static description = 'Push ACF field groups, post types, taxonomies, and options pages to WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps acf push', '$ lps acf push --type field-groups'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -34,9 +35,10 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'ACF object')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { path, status: 'dry-run', types };
         await this.recordSuccess();
         this.log('All ACF objects pushed.');
+        return { path, status: 'success', types };
     }
     async currentRevision(type, key) {
         try {

package/dist/commands/api/publish.js

@@ -16,7 +16,7 @@ export default class Publish extends Command {
         path: Args.string({ description: 'Path to api directory (overrides project config)' }),
     };
     static description = 'Publish custom API routes to your Loopress account so they can be deployed to other projects. Does not touch any WordPress site.';
-    static examples = ['$ lps api publish', '$ lps api publish --path ./api'];
+    static examples = ['$ lps api publish', '$ lps api publish ./api'];
     async run() {
         const { args } = await this.parse(Publish);
         const { apiProjectId, localConfig, token } = await resolveLinkedProject((message) => this.error(message));

package/dist/commands/app/push.js

@@ -63,7 +63,7 @@ export default class Push extends PushCommand {
             .filter((entry) => entry.isDirectory())
             .map((entry) => entry.name)
             .filter((name) => existsSync(join(path, name, APP_CONFIG_FILENAME)))
-            .sort((a, b) => a.localeCompare(b));
+            .toSorted((a, b) => a.localeCompare(b));
         if (only) {
             if (!names.includes(only)) {
                 this.error(`No app "${only}" in ${path} (looked for ${join(only, APP_CONFIG_FILENAME)}).`);

package/dist/commands/composer/push.js

@@ -3,8 +3,8 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
-import { isTimeoutError } from '../../lib/wp-client.js';
-import { toIntent } from '../../utils/composer.js';
+import { isLocalEnvironment, isTimeoutError } from '../../lib/wp-client.js';
+import { requireToInstall, toIntent } from '../../utils/composer.js';
 import { parseCollisions, SYNC_TIMEOUT_MS, } from '../../utils/plugin-sync.js';
 export default class ComposerPush extends PushCommand {
     static description = 'Push composer.json to WordPress and run Composer to resolve and install dependencies';
@@ -25,7 +25,7 @@ export default class ComposerPush extends PushCommand {
             this.error(`No composer.json found at ${composerJsonPath}. Run \`lps composer init\` first.`);
         }
         const parsed = JSON.parse(await readFile(composerJsonPath, 'utf8'));
-        const require = parsed.require ?? {};
+        const require = requireToInstall(parsed, isLocalEnvironment(this.siteConfig.name));
         const packageCount = Object.keys(require).length;
         const intent = toIntent(require);
         const hasLock = existsSync(composerLockPath);

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

@@ -1,13 +1,21 @@
 import { LoopressCommand } from '../../lib/base.js';
+type FormPullResult = {
+    orphans: string[];
+    path: string;
+    skipped: number;
+    status: 'dry-run' | 'success';
+};
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<FormPullResult>;
 }
+export {};

package/dist/commands/form/pull.js

@@ -11,6 +11,7 @@ export default class Pull extends LoopressCommand {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
     };
     static description = 'Pull forms from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps form pull'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -46,9 +47,10 @@ export default class Pull extends LoopressCommand {
             },
         });
         if (this.dryRun)
-            return;
+            return { orphans, path, skipped, status: 'dry-run' };
         if (skipped > 0) {
             this.warn(`${pluralize(skipped, 'form')} skipped because they have no id`);
         }
+        return { orphans, path, skipped, status: 'success' };
     }
 }

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

@@ -1,9 +1,14 @@
 import { PushCommand } from '../../lib/push-command.js';
+type FormPushResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+};
 export default class Push extends PushCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         'allow-notifications': import("@oclif/core/interfaces").BooleanFlag<boolean>;
@@ -11,9 +16,10 @@ export default class Push extends PushCommand {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     private allowNotifications;
-    run(): Promise<void>;
+    run(): Promise<FormPushResult>;
     private currentRevision;
     private ensureCanonicalFilename;
     private loadFiles;
     private pushForm;
 }
+export {};

package/dist/commands/form/push.js

@@ -14,6 +14,7 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
     };
     static description = 'Push forms to WordPress. Local files created or updated remotely are renamed on disk to the `<id>-<slug>.json` convention.';
+    static enableJsonFlag = true;
     static examples = ['$ lps form push', '$ lps form push --allow-notifications'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -41,9 +42,10 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'form')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { path, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All forms pushed.');
+        return { path, status: 'success' };
     }
     async currentRevision(id) {
         try {

package/dist/commands/init.js

@@ -1,4 +1,4 @@
-import { checkbox, confirm, input, select } from '@inquirer/prompts';
+import { confirm, input, select } from '@inquirer/prompts';
 import { Command } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
@@ -11,19 +11,6 @@ const SNIPPET_PROVIDERS = [
     { name: 'Code Snippets', slug: 'code-snippets' },
     { name: 'WPCode', slug: 'insert-headers-and-footers' },
 ];
-// Default directory per optional feature, matching the resolve*Path defaults in lib/base.ts.
-const FEATURES = [
-    { dir: 'acf', key: 'acfDir', label: 'ACF' },
-    { dir: 'seo', key: 'seoDir', label: 'SEO' },
-    { dir: 'menus', key: 'menuDir', label: 'Menus' },
-    { dir: 'forms', key: 'formDir', label: 'Forms' },
-    { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
-    { dir: 'hooks', key: 'hooksDir', label: 'Hooks (actions, filters, cron)' },
-    { dir: 'apps', key: 'appsDir', label: 'Single-page apps' },
-    { dir: 'pages', key: 'pageDir', label: 'Static pages' },
-    { dir: 'templates', key: 'templateDir', label: 'Block templates' },
-    { dir: 'parts', key: 'partDir', label: 'Block template parts' },
-];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';
     static examples = ['$ lps init'];
@@ -48,27 +35,13 @@ export default class Init extends Command {
             default: '.',
             message: 'Root directory',
         });
-        const snippetsDir = await input({
-            default: 'snippets',
-            message: 'Snippets directory (relative to root)',
-        });
-        const features = await checkbox({
-            choices: FEATURES.map((feature) => ({ name: `${feature.label} (${feature.dir}/)`, value: feature.key })),
-            message: 'Other features to configure directories for (optional)',
-        });
         const providerChoice = await select({
             choices: [...SNIPPET_PROVIDERS.map((p) => ({ name: p.name, value: p.slug })), { name: 'None / already installed', value: '__none__' }],
             message: 'Snippet provider',
         });
-        const config = {
-            projectId,
-            rootDir,
-            snippetsDir,
-        };
-        for (const feature of FEATURES) {
-            if (features.includes(feature.key))
-                config[feature.key] = feature.dir;
-        }
+        // Resource directories are left out on purpose: every command falls back to its default
+        // (utils/resource-dirs.ts), and a custom name is a one-line edit in loopress.json.
+        const config = { projectId, rootDir };
         await writeLocalConfig(config);
         const isGitattributesUpdated = await ensureLfGitattributes();
         let isProviderAdded = false;
@@ -83,19 +56,14 @@ export default class Init extends Command {
         }
         this.log(`\n✓ loopress.json created`);
         this.log(`  Project:  ${projectLabel}`);
-        this.log(`  Snippets: ${join(rootDir, snippetsDir)}`);
-        for (const feature of FEATURES) {
-            if (features.includes(feature.key)) {
-                this.log(`  ${feature.label}:${' '.repeat(Math.max(1, 9 - feature.label.length))}${join(rootDir, feature.dir)}`);
-            }
-        }
+        this.log(`  Root:     ${rootDir}`);
         if (isProviderAdded) {
             this.log(`  Plugin:   ${providerChoice}`);
         }
         if (isGitattributesUpdated) {
             this.log('✓ .gitattributes: LF line endings, so files match across macOS, Linux and Windows');
         }
-        this.log('\n→ Next: run `lps snippet pull` to fetch what is already on the site, or `lps doctor` to verify the connection.');
+        this.log('\n→ Next: run `lps pull` to fetch what is already on the site, or `lps doctor` to verify the connection.');
     }
     // When nothing is configured yet, the useful path is configuring a project right here, not
     // typing a project ID that points at nothing. Manual entry stays available as an explicit

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

@@ -1,15 +1,21 @@
 import { LoopressCommand } from '../../lib/base.js';
+type MenuPullResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+};
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<MenuPullResult>;
     private pullLocations;
     private pullMenus;
 }
+export {};

package/dist/commands/menu/pull.js

@@ -12,6 +12,7 @@ export default class Pull extends LoopressCommand {
         path: Args.string({ description: 'Path to menus directory (overrides project config)' }),
     };
     static description = 'Pull nav menus and the active theme menu locations from WordPress';
+    static enableJsonFlag = true;
     static examples = ['$ lps menu pull'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -25,6 +26,7 @@ export default class Pull extends LoopressCommand {
         this.log(`Menus path: ${path}`);
         await this.pullMenus(path);
         await this.pullLocations(path);
+        return { path, status: this.dryRun ? 'dry-run' : 'success' };
     }
     async pullLocations(basePath) {
         const file = join(basePath, `${LOCATIONS_FILE_BASENAME}.json`);

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

@@ -1,17 +1,23 @@
 import { PushCommand } from '../../lib/push-command.js';
+type MenuPushResult = {
+    path: string;
+    status: 'dry-run' | 'success';
+};
 export default class Push extends PushCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<MenuPushResult>;
     private currentRevision;
     private pushLocations;
     private pushMenuFile;
     private pushMenus;
 }
+export {};

package/dist/commands/menu/push.js

@@ -15,6 +15,7 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to menus directory (overrides project config)' }),
     };
     static description = 'Push local nav menus and the active theme menu locations to WordPress. Each menu\'s post_type/taxonomy items are resolved by slug on the target environment, never by a raw id; an item whose target does not exist there fails the whole menu rather than guessing.';
+    static enableJsonFlag = true;
     static examples = ['$ lps menu push'];
     static flags = {
         ...PushCommand.dryRunFlag,
@@ -35,9 +36,10 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'menu')} failed to push.`);
         }
         if (this.dryRun)
-            return;
+            return { path, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All nav menus pushed.');
+        return { path, status: 'success' };
     }
     async currentRevision(slug) {
         try {

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/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) {