@loopress/cli 0.30.0 → 0.32.0

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

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

package/dist/commands/acf/diff.js

@@ -1,5 +1,7 @@
 import { resourceDiffCommand } from '../../lib/diff-command.js';
-export default resourceDiffCommand('acf', {
+const Command = resourceDiffCommand('acf', {
     description: 'Show what differs in ACF field groups, post types, taxonomies, and options pages between your local files and a WordPress environment, or between two environments',
     pathNoun: 'ACF directory',
 });
+Command.aliases = ['scf:diff'];
+export default Command;

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

@@ -1,5 +1,6 @@
 import { LoopressCommand } from '../../lib/base.js';
 export default class List extends LoopressCommand {
+    static aliases: string[];
     static description: string;
     static enableJsonFlag: boolean;
     static examples: string[];

package/dist/commands/acf/list.js

@@ -2,7 +2,8 @@ import { Flags } from '@oclif/core';
 import { LoopressCommand } from '../../lib/base.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class List extends LoopressCommand {
-    static description = 'List ACF field groups, post types, taxonomies, and options pages from WordPress';
+    static aliases = ['scf:list'];
+    static description = 'List ACF field groups, post types, taxonomies, and options pages currently on WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps acf list', '$ lps acf list --type field-groups'];
     static flags = {

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

@@ -6,6 +6,7 @@ type AcfPullResult = {
     types: AcfObjectType[];
 };
 export default class Pull extends LoopressCommand {
+    static aliases: string[];
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };

package/dist/commands/acf/pull.js

@@ -5,10 +5,11 @@ import { LoopressCommand } from '../../lib/base.js';
 import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class Pull extends LoopressCommand {
+    static aliases = ['scf:pull'];
     static args = {
         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 description = 'Pull ACF field groups, post types, taxonomies, and options pages from WordPress into local files';
     static enableJsonFlag = true;
     static examples = ['$ lps acf pull', '$ lps acf pull --type field-groups'];
     static flags = {

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

@@ -1,11 +1,16 @@
-import { PushCommand } from '../../lib/push-command.js';
-import { type AcfObjectType } from '../../utils/acf-format.js';
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
+import { acfFieldChanges, type AcfObjectType } from '../../utils/acf-format.js';
+type AcfChange = PushChange & {
+    fields?: ReturnType<typeof acfFieldChanges>;
+};
 type AcfPushResult = {
+    changes?: AcfChange[];
     path: string;
     status: 'dry-run' | 'success';
     types: AcfObjectType[];
 };
 export default class Push extends PushCommand {
+    static aliases: string[];
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };

package/dist/commands/acf/push.js

@@ -4,13 +4,14 @@ import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { getResourceStateProvider } from '../../lib/resource-state.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
-import { ACF_OBJECT_TYPES, acfEndpoint, acfObjectEndpoint, getAcfKey } from '../../utils/acf-format.js';
+import { ACF_OBJECT_TYPES, acfEndpoint, acfFieldChanges, acfObjectEndpoint, getAcfKey } from '../../utils/acf-format.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Push extends PushCommand {
+    static aliases = ['scf:push'];
     static args = {
         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 description = 'Push local 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 = {
@@ -26,7 +27,8 @@ export default class Push extends PushCommand {
         this.log(`Pushing ACF configuration to ${url}`);
         this.log(`ACF path: ${path}`);
         const provider = getResourceStateProvider('acf');
-        const beforeState = await this.captureBeforePushState(provider, path);
+        // `--type` leaves the other types untouched: only the pushed ones count as overwritten.
+        const beforeState = await this.captureBeforePushState(provider, path, (id) => types.some((type) => id.startsWith(`${type}/`)));
         for (const type of types) {
             await this.pushType(type, path);
         }
@@ -34,8 +36,15 @@ export default class Push extends PushCommand {
         if (this.failedCount > 0) {
             this.error(`${pluralize(this.failedCount, 'ACF object')} failed to push.`);
         }
-        if (this.dryRun)
-            return { path, status: 'dry-run', types };
+        if (this.dryRun) {
+            const states = this.previewStates;
+            const changes = this.previewChanges.map((change) => {
+                if (!states || change.status !== 'changed' || !change.id.startsWith('field-groups/'))
+                    return change;
+                return { ...change, fields: acfFieldChanges(states.remote.get(change.id), states.local.get(change.id)) };
+            });
+            return { changes, path, status: 'dry-run', types };
+        }
         await this.recordSuccess();
         this.log('All ACF objects pushed.');
         return { path, status: 'success', types };

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

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

package/dist/commands/acf/rollback.js

@@ -1,5 +1,7 @@
 import { resourceRollbackCommand } from '../../lib/rollback-command.js';
-export default resourceRollbackCommand('acf', {
+const Command = resourceRollbackCommand('acf', {
     description: 'Restore ACF field groups, post types, taxonomies, and options pages to a snapshot taken automatically before an earlier `lps acf push`',
     pathNoun: 'ACF directory',
 });
+Command.aliases = ['scf:rollback'];
+export default Command;

package/dist/commands/composer/pull.js

@@ -10,7 +10,7 @@ function isMissingComposerLock(error) {
     return isApplicative404(error, 'composer.lock not found');
 }
 export default class ComposerPull extends LoopressCommand {
-    static description = 'Pull composer.json and composer.lock from WordPress';
+    static description = 'Pull composer.json and composer.lock from WordPress into local files';
     static enableJsonFlag = true;
     static examples = ['$ lps composer pull', '$ lps composer pull --dry-run'];
     static flags = {

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

@@ -17,5 +17,6 @@ export default class ComposerPush extends PushCommand {
     };
     run(): Promise<PushResult>;
     private reportLockDrift;
+    private wpackagistToRemove;
 }
 export {};

package/dist/commands/composer/push.js

@@ -2,6 +2,7 @@ import { Flags } from '@oclif/core';
 import { existsSync } from 'node:fs';
 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 { isLocalEnvironment, isTimeoutError } from '../../lib/wp-client.js';
 import { requireToInstall, toIntent } from '../../utils/composer.js';
@@ -37,8 +38,15 @@ export default class ComposerPush extends PushCommand {
         this.log(`Pushing composer.json (${packageCount} ${packageCount === 1 ? 'package' : 'packages'}) to ${url}`);
         if (lock)
             this.log('  + composer.lock sent for drift comparison (the server resolves versions from composer.json)');
+        // The server renders composer.json from this intent alone, so a WordPress.org plugin or theme
+        // the site has and this file lacks gets uninstalled, active or not: say so before it happens.
+        const toRemove = await this.wpackagistToRemove(require);
+        if (toRemove.length > 0)
+            this.log(`Would uninstall from the site, absent from composer.json: ${toRemove.join(', ')}`);
         if (this.dryRun)
             return { hasLock, lockDrift: [], packageCount, status: 'dry-run' };
+        if (!(await confirmUninstall(toRemove, this.yes)))
+            this.error('Aborted.');
         this.log('Running Composer on the server, this can take a few minutes...');
         let response;
         try {
@@ -74,4 +82,9 @@ export default class ComposerPush extends PushCommand {
         }
         this.log('Run `lps composer pull` to update your local composer.json and composer.lock.');
     }
+    async wpackagistToRemove(require) {
+        const { composerJson } = await this.wp.get('loopress/v1/composer/json');
+        const current = JSON.parse(composerJson).require ?? {};
+        return Object.keys(current).filter((name) => name.startsWith('wpackagist-') && !Object.hasOwn(require, name));
+    }
 }

package/dist/commands/content/copy.d.ts

@@ -0,0 +1,28 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { WpClient } from '../../lib/wp-client.js';
+type ContentCopyResult = {
+    from: string;
+    posts: number;
+    status: 'copied' | 'dry-run';
+    terms: number;
+};
+export default class Copy extends LoopressCommand {
+    static args: {
+        from: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static baseFlags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    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<ContentCopyResult>;
+    protected sourceWp(from: string): WpClient;
+    private confirmReplace;
+    private copy;
+}
+export {};

package/dist/commands/content/copy.js

@@ -0,0 +1,97 @@
+import { confirm } from '@inquirer/prompts';
+import { Args, Flags } from '@oclif/core';
+import { configManager } from '../../config/project-config.manager.js';
+import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.js';
+import { stdoutToStderr } from '../../lib/json-delegation.js';
+import { isLocalEnvironment, LOCAL_ENVIRONMENT_NAME, WpClient } from '../../lib/wp-client.js';
+import { pluralize } from '../../utils/pluralize.js';
+const BATCH_SIZE = 100;
+// Code goes up, content comes down: the content of <from> replaces the local site's, IDs
+// unchanged, never the reverse and never into the repo. Not a `pull`: nothing is written to
+// local files. The target is always "local", so there is no --env (this.wp is the local site),
+// <from> names the source like `lps promote`. Terms go first, so the post batches can attach
+// their term relationships. The plugin refuses the import on any site whose environment type is
+// not "local", whatever this command is pointed at.
+export default class Copy extends LoopressCommand {
+    static args = {
+        from: Args.string({ description: 'Environment to copy the content from', required: true }),
+    };
+    // Hidden, not removed: the type of LoopressCommand.baseFlags requires it. Any value other than
+    // "local" is refused in run().
+    static baseFlags = {
+        env: Flags.string({ hidden: true }),
+    };
+    static description = 'Replace the local site\'s content (posts, pages, public custom post types, terms) with the content of <from>, then push the project to the local site so tracked configuration wins. Media stay served by <from>, users, comments and orders are never copied.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps content copy production', '$ lps content copy staging --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Copy);
+        const { from } = args;
+        if (!isLocalEnvironment(this.siteConfig.name)) {
+            this.error(`Content is only ever copied into the "${LOCAL_ENVIRONMENT_NAME}" environment. Run \`lps project config\` to add it if the project has none.`);
+        }
+        if (isLocalEnvironment(from)) {
+            this.error(`<from> must be another environment than "${LOCAL_ENVIRONMENT_NAME}", e.g. \`lps content copy production\`.`);
+        }
+        const source = this.sourceWp(from);
+        if (!this.dryRun)
+            await this.confirmReplace(from);
+        const info = await source.get('loopress/v1/content');
+        if (!this.dryRun) {
+            await this.wp.post('loopress/v1/content/reset', { home: info.home, uploadsUrl: info.uploadsUrl });
+        }
+        this.log(`\n→ Copying terms from ${from}...`);
+        const terms = await this.copy('terms', source);
+        this.log(`→ Copying posts from ${from}...`);
+        const posts = await this.copy('posts', source);
+        const summary = `${pluralize(posts, 'post')} and ${pluralize(terms, 'term')}`;
+        if (this.dryRun) {
+            this.log(`\n[dry-run] Would replace the local content with ${summary} from ${from}, then push the project to ${LOCAL_ENVIRONMENT_NAME}.`);
+            return { from, posts, status: 'dry-run', terms };
+        }
+        this.log(`\n→ Pushing the project to ${LOCAL_ENVIRONMENT_NAME}...`);
+        await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', ['--env', LOCAL_ENVIRONMENT_NAME, '--yes']));
+        this.log(`\nCopied ${summary} from ${from}.`);
+        return { from, posts, status: 'copied', terms };
+    }
+    // Overridable seam for tests, like `wpClient` on LoopressCommand.
+    sourceWp(from) {
+        const project = configManager.getProject(this.projectId);
+        const env = project?.environments[from];
+        if (!env) {
+            this.error(`Environment "${from}" not found. Available: ${Object.keys(project?.environments ?? {}).join(', ')}`);
+        }
+        if (!env.token)
+            this.error(`No credentials configured for ${env.url}. Run \`lps project config\` to add them.`);
+        return new WpClient(env.url, env.token, env.name);
+    }
+    async confirmReplace(from) {
+        if (this.yes)
+            return;
+        const message = `This deletes the posts, pages and terms of the "${LOCAL_ENVIRONMENT_NAME}" site and replaces them with ${from}'s.`;
+        if (!isInteractive())
+            this.error(`${message} Pass --yes to confirm.`);
+        const isProceed = await confirm({ default: true, message: `${message} Continue?` });
+        if (!isProceed)
+            this.error('Aborted.');
+    }
+    // Pages through the source, each page posted to the local site as is.
+    async copy(kind, source) {
+        let count = 0;
+        let after = 0;
+        while (after !== null) {
+            const page = await source.get(`loopress/v1/content/${kind}?after=${after}&limit=${BATCH_SIZE}`);
+            const { next, ...rows } = page;
+            count += rows[kind].length;
+            if (!this.dryRun)
+                await this.wp.post(`loopress/v1/content/${kind}`, rows);
+            after = next;
+        }
+        return count;
+    }
+}

package/dist/commands/diff.d.ts

@@ -9,5 +9,6 @@ export default class Diff extends DiffCommand {
         against: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<DiffJson>;
+    private projectUses;
     private selectResources;
 }

package/dist/commands/diff.js

@@ -1,13 +1,15 @@
 import { Flags } from '@oclif/core';
 import { DiffCommand } from '../lib/diff-command.js';
 import { RESOURCE_STATE_PROVIDERS } from '../lib/resource-state.js';
+import { projectUses, resolveResourceDir } from '../utils/resource-dirs.js';
+import { globalStylesFiles } from '../utils/theme-styles-format.js';
 // Everything `lps diff` can compare, in report order. Composer isn't a directory-backed
 // provider (see resource-state.ts) so it's named here explicitly.
 const RESOURCES = [...RESOURCE_STATE_PROVIDERS.map((provider) => provider.resource), 'composer'];
 export default class Diff extends DiffCommand {
     static description = [
         'Show what differs between your local tracked files and a WordPress environment, or between two environments.',
-        'Covers snippets, forms, ACF, API routes, Hooks, templates, template parts, pages, Options, Menus, Theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
+        'Covers snippets, forms, ACF, API routes, hooks, templates, template parts, pages, menus, custom post types, taxonomies, post meta, roles, block patterns, options, theme styles, and Composer. Plugins and themes have their own `lps plugin status` / `lps theme status`.',
         'Exit code: 0 in sync, 1 on drift, 2 when a resource could not be compared, so it doubles as a CI drift gate.',
     ].join(' ');
     static enableJsonFlag = true;
@@ -27,12 +29,21 @@ export default class Diff extends DiffCommand {
         const { flags } = await this.parse(Diff);
         const sides = this.resolveSides(flags.against);
         const selected = this.selectResources(flags.only, flags.skip);
+        const providers = RESOURCE_STATE_PROVIDERS.filter((provider) => selected.has(provider.resource));
         const targets = [
-            ...RESOURCE_STATE_PROVIDERS.filter((provider) => selected.has(provider.resource)).map((provider) => this.providerTarget(provider, sides)),
+            ...(await Promise.all(providers.map(async (provider) => ({ ...this.providerTarget(provider, sides), optional: !(await this.projectUses(provider)) })))),
             ...(selected.has('composer') ? [this.composerTarget(sides)] : []),
         ];
         return this.report(targets, sides);
     }
+    // Tells apart a resource the project doesn't use from one it does, for the ones a site can lack:
+    // a plugin-backed resource without its directory, Global Styles without a tracked file.
+    async projectUses(provider) {
+        if (provider.dirKind === 'themeStyles') {
+            return (await globalStylesFiles(resolveResourceDir('themeStyles', this.localConfig))).length > 0;
+        }
+        return projectUses(provider.dirKind, this.localConfig);
+    }
     // `--only` narrows the default set, `--skip` then removes from whatever that set is, same
     // precedence a combined `--only=a,b --skip=b` reads as (mirrors dev-watch's resolveResourceTypes).
     selectResources(only, skip) {

package/dist/commands/doctor.d.ts

@@ -19,6 +19,7 @@ export default class Doctor extends LoopressCommand {
     private readonly checks;
     run(): Promise<DoctorResult>;
     private check;
+    private checkHookErrors;
     private checkLeftoverTempAdmins;
     private out;
     private reportPluginVersion;

package/dist/commands/doctor.js

@@ -1,11 +1,12 @@
 import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
+import { formatRuntimeError, HOOK_FILES_RESOURCE } from '../lib/php-files-command.js';
 import { findTempAdmins } from '../lib/temp-admin.js';
 import { isForbiddenError, isNotFoundError } from '../lib/wp-client.js';
 import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
 import { pluralize } from '../utils/pluralize.js';
 export default class Doctor extends LoopressCommand {
-    static description = 'Diagnose connectivity, plugin and credential problems for the targeted environment';
+    static description = 'Diagnose connectivity, plugin, credential and hook problems for the targeted environment';
     static enableJsonFlag = true;
     static examples = ['$ lps doctor', '$ lps doctor --env production'];
     checks = [];
@@ -35,8 +36,10 @@ export default class Doctor extends LoopressCommand {
                 // application password without depending on any Loopress feature.
                 const isAuthenticated = await this.check('Credentials accepted (authenticated request)', async () => this.wp.get('wp/v2/users/me'));
                 // Skipped when the credentials were just rejected: it would only repeat that same 401.
-                if (isAuthenticated)
+                if (isAuthenticated) {
                     await this.checkLeftoverTempAdmins();
+                    await this.checkHookErrors();
+                }
                 pluginVersion = await this.reportPluginVersion();
             }
             else {
@@ -76,6 +79,30 @@ export default class Doctor extends LoopressCommand {
             return false;
         }
     }
+    // A hook that fails to load or throws while running doesn't break the site, it just quietly
+    // does nothing, and its only trace is an error_log nobody reads on managed hosting.
+    async checkHookErrors() {
+        let lookup;
+        try {
+            lookup = { files: await this.wp.get(HOOK_FILES_RESOURCE.endpoint) };
+        }
+        catch (error) {
+            if (isNotFoundError(error))
+                return; // Loopress Light has no hooks
+            lookup = { error };
+        }
+        await this.check('Hooks load and run without errors', async () => {
+            if ('error' in lookup)
+                throw lookup.error;
+            const files = Array.isArray(lookup.files) ? lookup.files : [];
+            const problems = files.flatMap((file) => [
+                ...(file.error ? [`hooks/${file.filename}.php: ${file.error}`] : []),
+                ...(file.runtimeError ? [`hooks/${file.filename}.php: ${formatRuntimeError(file.runtimeError)}`] : []),
+            ]);
+            if (problems.length > 0)
+                throw new Error(problems.join('\n  '));
+        });
+    }
     // Report only, never deletes: a doctor run shouldn't change the site. A leftover is a live
     // administrator with a password nobody holds, so it fails the run. Credentials without
     // `list_users` can't look, which is informational, not a failure: nothing was found wrong.

package/dist/commands/form/list.js

@@ -1,7 +1,7 @@
 import { LoopressCommand } from '../../lib/base.js';
 import { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
 export default class List extends LoopressCommand {
-    static description = 'List forms from WordPress';
+    static description = 'List forms currently on WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps form list'];
     async run() {

package/dist/commands/form/pull.js

@@ -10,7 +10,7 @@ export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
     };
-    static description = 'Pull forms from WordPress';
+    static description = 'Pull forms from WordPress into local files';
     static enableJsonFlag = true;
     static examples = ['$ lps form pull'];
     static flags = {

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

@@ -1,5 +1,6 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
 type FormPushResult = {
+    changes?: PushChange[];
     path: string;
     status: 'dry-run' | 'success';
 };

package/dist/commands/form/push.js

@@ -1,5 +1,5 @@
 import { Args, Flags } from '@oclif/core';
-import { readFile, rename } from 'node:fs/promises';
+import { readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname, extname, join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { putOrCreate } from '../../lib/put-or-create.js';
@@ -13,7 +13,7 @@ export default class Push extends PushCommand {
     static args = {
         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 description = 'Push local form files 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 = {
@@ -42,7 +42,7 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'form')} failed to push.`);
         }
         if (this.dryRun)
-            return { path, status: 'dry-run' };
+            return { changes: this.previewChanges, path, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All forms pushed.');
         return { path, status: 'success' };
@@ -120,6 +120,9 @@ export default class Push extends PushCommand {
                 putEndpoint: formEndpoint,
             });
             const canonicalId = created ? getFormId(body) : id;
+            // The id is read from the file, not its name: without it the next push creates the form again.
+            if (created && canonicalId !== null)
+                await writeFile(filePath, JSON.stringify({ ...data, id: canonicalId }, null, 2) + '\n');
             if (canonicalId !== null)
                 await this.ensureCanonicalFilename(filePath, canonicalId, title);
             if (task)

package/dist/commands/init.js

@@ -5,12 +5,6 @@ import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { isInteractive } from '../lib/interactive.js';
 import { ensureLfGitattributes, writeLocalConfig } from '../utils/loopress-config.js';
-// WordPress.org slugs for the two snippet plugins the Loopress WordPress plugin supports
-// (see SnippetModule.php, which wires up both providers and auto-detects the active one).
-const SNIPPET_PROVIDERS = [
-    { name: 'Code Snippets', slug: 'code-snippets' },
-    { name: 'WPCode', slug: 'insert-headers-and-footers' },
-];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';
     static examples = ['$ lps init'];
@@ -35,31 +29,14 @@ export default class Init extends Command {
             default: '.',
             message: 'Root directory',
         });
-        const providerChoice = await select({
-            choices: [...SNIPPET_PROVIDERS.map((p) => ({ name: p.name, value: p.slug })), { name: 'None / already installed', value: '__none__' }],
-            message: 'Snippet provider',
-        });
         // 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;
-        if (providerChoice !== '__none__') {
-            try {
-                await this.config.runCommand('plugin:add', [providerChoice]);
-                isProviderAdded = true;
-            }
-            catch (error) {
-                this.warn(error.message);
-            }
-        }
         this.log(`\n✓ loopress.json created`);
         this.log(`  Project:  ${projectLabel}`);
         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');
         }

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

@@ -1,5 +1,6 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
 type MenuPushResult = {
+    changes?: PushChange[];
     path: string;
     status: 'dry-run' | 'success';
 };

package/dist/commands/menu/push.js

@@ -36,7 +36,7 @@ export default class Push extends PushCommand {
             this.error(`${pluralize(this.failedCount, 'menu')} failed to push.`);
         }
         if (this.dryRun)
-            return { path, status: 'dry-run' };
+            return { changes: this.previewChanges, path, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All nav menus pushed.');
         return { path, status: 'success' };

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

@@ -1,5 +1,6 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
 type PushResult = {
+    changes?: PushChange[];
     pushed: string[];
     skipped: string[];
     status: 'dry-run' | 'success';

package/dist/commands/option/push.js

@@ -23,8 +23,6 @@ export default class Push extends PushCommand {
         const { url } = this.siteConfig;
         this.log(`Pushing tracked options to ${url}`);
         this.log(`Options path: ${dir}`);
-        const provider = getResourceStateProvider('option');
-        const beforeState = await this.captureBeforePushState(provider, dir);
         const tracked = await loadFiles(dir, {
             extension: '.json',
             onSkip: (message) => {
@@ -33,6 +31,10 @@ export default class Push extends PushCommand {
             parse: parseLocalOption,
         });
         const { skipped, writable } = partitionByReadonly(tracked);
+        const provider = getResourceStateProvider('option');
+        // Readonly options are never written, so a site-side change to one is no reason to stop.
+        const writableNames = new Set(writable.map((option) => option.name));
+        const beforeState = await this.captureBeforePushState(provider, dir, (name) => writableNames.has(name));
         if (skipped.length > 0) {
             this.log(`Skipping ${pluralize(skipped.length, 'readonly option')}: ${skipped.map((option) => option.name).join(', ')}`);
         }
@@ -48,7 +50,7 @@ export default class Push extends PushCommand {
         }
         const skippedNames = skipped.map((option) => option.name);
         if (this.dryRun)
-            return { pushed, skipped: skippedNames, status: 'dry-run' };
+            return { changes: this.previewChanges, pushed, skipped: skippedNames, status: 'dry-run' };
         await this.recordSuccess();
         this.log('All options pushed.');
         return { pushed, skipped: skippedNames, status: 'success' };

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

@@ -1,5 +1,6 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { type PushChange, PushCommand } from '../../lib/push-command.js';
 type PushResult = {
+    changes?: PushChange[];
     pushed: string[];
     status: 'dry-run' | 'success';
 };
@@ -14,7 +15,9 @@ export default class Push extends PushCommand {
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
+    private readonly unmanaged;
     run(): Promise<PushResult>;
+    private adoptUnmanaged;
     private pushPage;
 }
 export {};