@loopress/cli 0.29.0 → 0.30.0

package/dist/hooks/finally.js

@@ -27,10 +27,18 @@ async function report(context, options) {
             dsn: SENTRY_DSN,
             environment: resolveEnvironment(),
             release: context.config.version,
+            // Sentry 11 collects all of these by default. Headers carry the app password, stack frame
+            // locals can hold it too, and this reports from users' own machines: collect none of it.
+            dataCollection: {
+                cookies: false,
+                httpBodies: [],
+                httpHeaders: false,
+                stackFrameVariables: false,
+                urlQueryParams: false,
+                userInfo: false,
+            },
             // Node defaults `server_name` to os.hostname(), which is often the user's real name
-            // (e.g. "jane-doe-macbook-pro"). sendDefaultPii covers IP addresses and similar, off by
-            // default but set explicitly since this reports from users' own machines.
-            sendDefaultPii: false,
+            // (e.g. "jane-doe-macbook-pro").
             serverName: 'loopress',
         });
         Sentry.captureException(options.error, {

package/dist/lib/api-client.js

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

package/dist/lib/app-build.js

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

package/dist/lib/base.d.ts

@@ -39,10 +39,9 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveHooksPath(override?: string): string;
     protected resolveMenuPath(override?: string): string;
     protected resolveOptionsPath(override?: string): string;
-    protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     protected resolveThemeStylesPath(override?: string): string;
+    protected warnRemovedSeoModule(): void;
     private pickEnvironment;
     private resolveEnvironment;
-    private resolveEnvironmentForConfiguredProject;
 }

package/dist/lib/base.js

@@ -1,6 +1,7 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
+import { existsSync } from 'node:fs';
 import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
@@ -9,13 +10,14 @@ import { pluralize } from '../utils/pluralize.js';
 import { resolveResourceDir } from '../utils/resource-dirs.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
+import { withoutSpinner } from './spinner.js';
 import { WpClient } from './wp-client.js';
 export class LoopressCommand extends Command {
-    // On every subclass without opt-in: targeting an environment explicitly beats depending on
-    // the machine-wide mutable state of `lps project switch`, which is shared across terminals.
+    // On every subclass without opt-in. Without it, commands target the "local" environment, so
+    // reaching a remote site is always spelled out in the command itself.
     static baseFlags = {
         env: Flags.string({
-            description: 'Target environment by name, overriding the globally active one (lps project switch)',
+            description: 'Target environment by name (default: "local", or the project\'s only environment)',
         }),
     };
     static dryRunFlag = {
@@ -107,13 +109,15 @@ export class LoopressCommand extends Command {
         }
         if (options.alwaysCreateDir === true || items.length > 0)
             await mkdir(dir, { recursive: true });
-        await new Listr(items.map((item) => ({
-            async task(_ctx, task) {
-                await options.write(item, dir);
-                task.output = `Pulled: ${options.title(item)}`;
-            },
-            title: `Pull ${options.title(item)}`,
-        })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        await withoutSpinner(async () => {
+            await new Listr(items.map((item) => ({
+                async task(_ctx, task) {
+                    await options.write(item, dir);
+                    task.output = `Pulled: ${options.title(item)}`;
+                },
+                title: `Pull ${options.title(item)}`,
+            })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        });
         await this.removeOrphanedFiles(dir, orphans, options.orphanReason);
         this.log(options.pulledMessage);
     }
@@ -165,15 +169,19 @@ export class LoopressCommand extends Command {
     resolveOptionsPath(override) {
         return resolveResourceDir('options', this.localConfig, override);
     }
-    resolveSeoPath(override) {
-        return resolveResourceDir('seo', this.localConfig, override);
-    }
     resolveSnippetsPath(override) {
         return resolveResourceDir('snippets', this.localConfig, override);
     }
     resolveThemeStylesPath(override) {
         return resolveResourceDir('themeStyles', this.localConfig, override);
     }
+    // `lps seo` was removed: a leftover seo/ folder or seoDir key would otherwise be silently
+    // ignored by `lps pull` / `lps push`. Remove once projects have had a release to migrate.
+    warnRemovedSeoModule() {
+        if (!('seoDir' in this.localConfig) && !existsSync(join(this.rootDir, 'seo')))
+            return;
+        this.warn('The SEO module was removed: seo/ is no longer pulled or pushed. Track SEO plugin settings with `lps option add rank-math-options-titles` (or `wpseo_titles`), then delete seo/ and any seoDir key from loopress.json.');
+    }
     pickEnvironment(project, envName) {
         const env = project.environments[envName];
         if (!env) {
@@ -181,24 +189,12 @@ export class LoopressCommand extends Command {
         }
         return env;
     }
+    // Order: --env, then the project's default (see getDefaultEnvironment). The project comes from
+    // loopress.json when pinned, from `lps project switch` otherwise.
     resolveEnvironment(envName) {
-        if (this.localConfig.projectId) {
-            return this.resolveEnvironmentForConfiguredProject(this.localConfig.projectId, envName);
-        }
-        if (envName) {
-            const current = configManager.getCurrentProject();
-            if (!current) {
-                this.error('No project configured. Run `lps project config` first.');
-            }
-            return { env: this.pickEnvironment(current, envName), projectId: current.id };
-        }
-        const env = configManager.getCurrentEnv();
-        const current = configManager.getCurrentProject();
-        if (env && current)
-            return { env, projectId: current.id };
-        this.error('No environment configured. Run `lps project config` first.');
-    }
-    resolveEnvironmentForConfiguredProject(projectId, envName) {
+        const projectId = this.localConfig.projectId ?? configManager.getCurrentProject()?.id;
+        if (!projectId)
+            this.error('No project configured. Run `lps project config` first.');
         const project = configManager.getProject(projectId);
         if (!project) {
             this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
@@ -209,14 +205,10 @@ export class LoopressCommand extends Command {
         }
         if (envName)
             return { env: this.pickEnvironment(project, envName), projectId };
-        if (envNames.length === 1) {
-            return { env: project.environments[envNames[0]], projectId };
-        }
-        const current = configManager.getCurrentProject();
-        const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
-        if (!currentEnv) {
-            this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
+        const env = configManager.getDefaultEnvironment(projectId);
+        if (!env) {
+            this.error(`Project "${project.name}" has no "local" environment, pass --env to pick one. Available: ${envNames.join(', ')}`);
         }
-        return { env: currentEnv, projectId };
+        return { env, projectId };
     }
 }

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

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

package/dist/lib/declared-type-command.js

@@ -0,0 +1,192 @@
+import { confirm } from '@inquirer/prompts';
+import { Args } from '@oclif/core';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileExtension, formatDeclaredFile, itemEndpoint, parseDeclaredFile, } from '../utils/declared-type-format.js';
+import { pluralize } from '../utils/pluralize.js';
+import { resolveResourceDir } from '../utils/resource-dirs.js';
+import { LoopressCommand } from './base.js';
+import { basenameKey, findOrphanedFiles } from './find-orphaned-files.js';
+import { isInteractive } from './interactive.js';
+import { loadFiles } from './load-files.js';
+import { PushCommand } from './push-command.js';
+import { getResourceStateProvider } from './resource-state.js';
+import { isApplicative404, isNotFoundError } from './wp-client.js';
+const SOURCE_LABELS = {
+    acf: 'ACF',
+    cptui: 'CPT UI',
+    loopress: 'Loopress',
+    other: 'theme or plugin',
+    wordpress: 'WordPress',
+};
+function pathArg(spec) {
+    return Args.string({ description: `Path to the ${spec.dir} directory (overrides project config)` });
+}
+export function declaredPushCommand(spec, description) {
+    class DeclaredPush extends PushCommand {
+        static args = { path: pathArg(spec) };
+        static description = description;
+        static enableJsonFlag = true;
+        static examples = [`$ lps ${spec.cliName} push`];
+        static flags = { ...PushCommand.dryRunFlag, ...PushCommand.yesFlag };
+        async run() {
+            const { args } = await this.parse(DeclaredPush);
+            const path = resolveResourceDir(spec.dirKind, this.localConfig, args.path);
+            this.log(`Pushing ${spec.plural} to ${this.siteConfig.url}`);
+            this.log(`Path: ${path}`);
+            const provider = getResourceStateProvider(spec.cliName);
+            const beforeState = await this.captureBeforePushState(provider, path);
+            const items = await loadFiles(path, {
+                extension: fileExtension(spec),
+                onSkip: (message) => {
+                    this.warn(message);
+                },
+                parse: (raw, filePath) => parseDeclaredFile(spec, filePath, raw),
+            });
+            this.log(`Found ${pluralize(items.length, spec.noun, spec.plural)} to push`);
+            const pushed = [];
+            await this.runPushTasks(items, (item) => item.slug, async (item, task) => {
+                await this.pushItem(item, task);
+                pushed.push(item.slug);
+            });
+            await this.writeAfterPushSnapshot(provider, path, beforeState);
+            if (this.failedCount > 0) {
+                this.error(`${pluralize(this.failedCount, spec.noun, spec.plural)} failed to push.`);
+            }
+            if (this.dryRun)
+                return { path, pushed, status: 'dry-run' };
+            await this.recordSuccess();
+            this.log(`All ${spec.plural} pushed.`);
+            return { path, pushed, status: 'success' };
+        }
+        async currentRevision(slug) {
+            try {
+                return (await this.wp.get(itemEndpoint(spec, slug))).revision;
+            }
+            catch (error) {
+                if (isNotFoundError(error))
+                    return undefined;
+                throw error;
+            }
+        }
+        async pushItem({ args, slug }, task) {
+            if (this.dryRun) {
+                if (task)
+                    task.output = `[dry-run] Would push: ${slug}`;
+                return;
+            }
+            try {
+                // Conditional write (#234), same as `menu push`: WordPress refuses it (412) if the item
+                // changed since this read. Slug, reserved names and code arguments are checked there.
+                const expectedRevision = await this.currentRevision(slug);
+                const body = { args, slug };
+                if (expectedRevision !== undefined)
+                    body.expectedRevision = expectedRevision;
+                await this.wp.post(spec.endpoint, body);
+                if (task)
+                    task.output = `Pushed: ${slug}`;
+            }
+            catch (error) {
+                this.reportTaskFailure(`Failed to push ${slug}: ${error.message}`, error, task);
+            }
+        }
+    }
+    return DeclaredPush;
+}
+export function declaredPullCommand(spec, description) {
+    class DeclaredPull extends LoopressCommand {
+        static args = { path: pathArg(spec) };
+        static description = description;
+        static enableJsonFlag = true;
+        static examples = [`$ lps ${spec.cliName} pull`];
+        static flags = { ...LoopressCommand.dryRunFlag, ...LoopressCommand.yesFlag };
+        async run() {
+            const { args } = await this.parse(DeclaredPull);
+            const path = resolveResourceDir(spec.dirKind, this.localConfig, args.path);
+            this.log(`Pulling ${spec.plural} from ${this.siteConfig.url}`);
+            this.log(`Path: ${path}`);
+            const remote = await this.wp.get(spec.endpoint);
+            const orphans = await findOrphanedFiles(path, new Set(remote.map(({ slug }) => slug)), { extensions: [fileExtension(spec)], key: basenameKey });
+            await this.pullDirectory(path, remote, orphans, {
+                dryRunMessage: `Would pull ${pluralize(remote.length, spec.noun, spec.plural)} to ${path}`,
+                orphanReason: `in ${path} no longer present on WordPress`,
+                pulledMessage: `Pulled ${pluralize(remote.length, spec.noun, spec.plural)} to ${path}`,
+                title: ({ slug }) => slug,
+                // Only the arguments: the slug is the file name, the revision is push bookkeeping.
+                async write(item, dir) {
+                    await writeFile(join(dir, `${item.slug}${fileExtension(spec)}`), formatDeclaredFile(spec, item.args));
+                },
+            });
+            return { path, status: this.dryRun ? 'dry-run' : 'success' };
+        }
+    }
+    return DeclaredPull;
+}
+// `countLabel` renders the item's count: "3 published" for a post type, "3 terms" for a taxonomy,
+// nothing when it returns an empty string.
+export function declaredListCommand(spec, description, countLabel) {
+    class DeclaredList extends LoopressCommand {
+        static description = description;
+        static enableJsonFlag = true;
+        static examples = [`$ lps ${spec.cliName} list`];
+        async run() {
+            const items = await this.wp.get(spec.registeredEndpoint);
+            for (const item of items) {
+                const attached = item.objectTypes && item.objectTypes.length > 0 ? `, on ${item.objectTypes.join(', ')}` : '';
+                const count = countLabel(item.count);
+                const counted = count ? ', ' + count : '';
+                this.log(`${item.slug} (${item.label}): ${SOURCE_LABELS[item.source]}${counted}${attached}`);
+                if (item.conflict) {
+                    this.warn(`${item.slug}: declared in ${spec.dir}/ but already registered by ${SOURCE_LABELS[item.source]}, the Loopress version is skipped`);
+                }
+            }
+            return items;
+        }
+    }
+    return DeclaredList;
+}
+// The only way a Loopress item leaves WordPress: push never deletes (see Push Deletion Rules in
+// the product docs). The local file is left alone, same as `hook rm`. `keptNote` says what
+// happens to what used it ("Its posts stay in the database, hidden until it's pushed again.").
+export function declaredRmCommand(spec, description, keptNote) {
+    class DeclaredRm extends LoopressCommand {
+        static aliases = [`${spec.cliName}:remove`];
+        static args = {
+            slug: Args.string({ description: `The ${spec.noun} slug, its ${spec.dir}/ file name without ${fileExtension(spec)}`, required: true }),
+        };
+        static description = description;
+        static enableJsonFlag = true;
+        static examples = [`$ lps ${spec.cliName} rm <slug>`, `$ lps ${spec.cliName} remove <slug> --yes`];
+        static flags = { ...LoopressCommand.dryRunFlag, ...LoopressCommand.yesFlag };
+        async run() {
+            const { args } = await this.parse(DeclaredRm);
+            const { slug } = args;
+            const { url } = this.siteConfig;
+            if (this.dryRun) {
+                this.log(`[dry-run] Would remove ${spec.noun} ${slug} from ${url}`);
+                return { removed: false, slug, status: 'dry-run' };
+            }
+            if (!this.yes) {
+                if (!isInteractive())
+                    this.error(`Removing ${spec.noun} ${slug} needs confirmation. Re-run with --yes.`);
+                const ok = await confirm({ default: false, message: `Remove ${spec.noun} ${slug} from ${url}? ${keptNote}` });
+                if (!ok) {
+                    this.log('Aborted.');
+                    return { removed: false, slug, status: 'aborted' };
+                }
+            }
+            try {
+                await this.wp.delete(itemEndpoint(spec, slug));
+            }
+            catch (error) {
+                const notFound = `${spec.noun[0].toUpperCase()}${spec.noun.slice(1)} not found`;
+                if (isApplicative404(error, notFound))
+                    this.error(`${spec.noun} ${slug} is not managed by Loopress on ${url}.`);
+                throw error;
+            }
+            this.log(`Removed ${spec.noun} ${slug} from ${url}. ${keptNote}`);
+            return { removed: true, slug, status: 'success' };
+        }
+    }
+    return DeclaredRm;
+}

package/dist/lib/dev-watch.d.ts

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'hooks' | 'pages' | 'parts' | 'plugins' | 'snippets' | 'templates';
+export type ResourceType = 'api' | 'blocks' | 'css' | 'hooks' | 'pages' | 'parts' | 'plugins' | 'snippets' | 'templates';
 export declare const RESOURCE_TYPES: ResourceType[];
 export type WatchTarget = {
     commandId: string;

package/dist/lib/dev-watch.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
-export const RESOURCE_TYPES = ['snippets', 'templates', 'parts', 'pages', 'api', 'hooks', 'plugins'];
+import { resolveResourceDir } from '../utils/resource-dirs.js';
+export const RESOURCE_TYPES = ['snippets', 'templates', 'parts', 'css', 'blocks', 'pages', 'api', 'hooks', 'plugins'];
 // `only` narrows the default set, `skip` then removes from whatever that set is, same
 // precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
 export function resolveResourceTypes(only, skip = []) {
@@ -15,11 +16,14 @@ export function buildWatchTargets(types, localConfig, cwd) {
     const rootDir = join(cwd, localConfig.rootDir ?? '.');
     const candidates = {
         api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        // The theme CSS is bundled into the child theme with the templates, by the same push.
+        blocks: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('blockCss', localConfig)), type: 'blocks' },
+        css: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('css', localConfig)), type: 'css' },
         hooks: { commandId: 'hook:push', path: join(rootDir, localConfig.hooksDir ?? 'hooks'), type: 'hooks' },
         pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
         plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
-        parts: { commandId: 'theme:template:push', path: join(rootDir, localConfig.partDir ?? 'parts'), type: 'parts' },
-        templates: { commandId: 'theme:template:push', path: join(rootDir, localConfig.templateDir ?? 'templates'), type: 'templates' },
+        parts: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('part', localConfig)), type: 'parts' },
+        templates: { commandId: 'theme:template:push', path: join(cwd, resolveResourceDir('template', localConfig)), type: 'templates' },
         snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
     };
     return types

package/dist/lib/github-release.js

@@ -4,6 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
+import { withSpinner } from './spinner.js';
 const REPO = 'loopress/loopress';
 const ASSET_NAME = 'loopress-full.zip';
 /**
@@ -17,6 +18,9 @@ const ASSET_NAME = 'loopress-full.zip';
  * "the one zip asset".
  */
 export async function downloadLatestFullZip() {
+    return withSpinner('Downloading Loopress Full', download);
+}
+async function download() {
     const releases = await got(`https://api.github.com/repos/${REPO}/releases`, {
         headers: { accept: 'application/vnd.github+json', 'user-agent': 'loopress-cli' },
         searchParams: { 'per_page': 30 },

package/dist/lib/local-callback-server.js

@@ -2,6 +2,7 @@ import { Buffer } from 'node:buffer';
 import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { openBrowser } from './open-browser.js';
+import { withSpinner } from './spinner.js';
 /** Constant-time compare that also tolerates a length mismatch without throwing. */
 function safeEqual(a, b) {
     const bufferA = Buffer.from(a);
@@ -28,7 +29,7 @@ function safeEqual(a, b) {
 export async function waitForLocalCallback(options) {
     const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
     const state = randomBytes(32).toString('hex');
-    return new Promise((resolve, reject) => {
+    const callback = new Promise((resolve, reject) => {
         function finish(res, page) {
             // `Connection: close` (here and below): server.close() only refuses new connections, a
             // kept-alive socket would otherwise still reach this handler after the shutdown.
@@ -100,6 +101,7 @@ export async function waitForLocalCallback(options) {
             openBrowser(targetUrl);
         });
     });
+    return withSpinner('Waiting for the browser', async () => callback);
 }
 /**
  * The page rewrites its own URL to `/` on load, so the callback query string (an Application

package/dist/lib/push-command.d.ts

@@ -15,6 +15,7 @@ export declare abstract class PushCommand extends LoopressCommand {
     protected previewRemote(provider: ResourceStateProvider, dir: string): Promise<void>;
     protected recordDeployment(status: 'failure' | 'success'): Promise<void>;
     protected recordSuccess(): Promise<void>;
+    protected reportPushToSite(): Promise<void>;
     protected reportTaskFailure(message: string, error: unknown, task?: {
         output: string;
     }): never;

package/dist/lib/push-command.js

@@ -7,6 +7,7 @@ import { API_URL } from './api-client.js';
 import { LoopressCommand } from './base.js';
 import { guardProductionPush } from './guard-production-push.js';
 import { writeSnapshot } from './snapshot-store.js';
+import { withoutSpinner, withSpinner } from './spinner.js';
 export class PushCommand extends LoopressCommand {
     // Passed by an aggregate command (`lps theme push`) that already confirmed production once,
     // so its steps skip that prompt while still asking their own confirmations (uninstalls).
@@ -78,19 +79,37 @@ export class PushCommand extends LoopressCommand {
         if (!token)
             return;
         try {
-            await got.post(`${API_URL}/deployments`, {
+            await withSpinner('Recording the deployment', async () => got.post(`${API_URL}/deployments`, {
                 headers: { Authorization: `Bearer ${token}` },
                 json: { status, url: this.siteConfig.url },
                 timeout: { request: 3000 },
-            });
+            }));
         }
         catch {
             // non-blocking: recording must never interrupt the push flow
         }
     }
     async recordSuccess() {
-        if (!this.dryRun)
-            await this.recordDeployment('success');
+        if (this.dryRun)
+            return;
+        await this.recordDeployment('success');
+        await this.reportPushToSite();
+    }
+    // Tells the plugin this push finished, for its Overview tab and the "managed by Loopress"
+    // warnings in wp-admin: one record per command (`this.id`, e.g. `acf:push`), since a single push
+    // sends one request per item. Best-effort like recordDeployment: a plugin older than the push
+    // log answers 404, one that doesn't know this command 400, neither may fail a push that landed.
+    async reportPushToSite() {
+        if (!this.id)
+            return;
+        try {
+            // Bounded: the site fingerprints the pushed resource before answering, which a large
+            // site can make slow, and a finished push must not wait on its own bookkeeping.
+            await this.wp.post('loopress/v1/pushes', { resource: this.id }, { timeoutMs: 5000 });
+        }
+        catch {
+            // non-blocking, see above
+        }
     }
     // Reports one failed Listr task: status lines go through `task.output` when running inside a
     // Listr renderer (this.warn would race with the repaint), and fall back to `this.warn` when
@@ -111,17 +130,19 @@ export class PushCommand extends LoopressCommand {
     // just the first. `label` feeds the "Push <label>" task title; `task` does the actual work
     // and reports its own failure through `reportTaskFailure`.
     async runPushTasks(items, label, task) {
-        await new Listr(items.map((item) => ({
-            task: async (_ctx, taskCtx) => task(item, taskCtx),
-            title: `Push ${label(item)}`,
-        })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        await withoutSpinner(async () => {
+            await new Listr(items.map((item) => ({
+                task: async (_ctx, taskCtx) => task(item, taskCtx),
+                title: `Push ${label(item)}`,
+            })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        });
     }
     // Pairs `beforeState` (from captureBeforePushState, read before this push touched anything)
     // with a fresh remote read taken right after the push, and writes both as one rollback
     // snapshot. Reading the after-state from WordPress itself, rather than assuming it matches
     // the local files that were pushed, is what keeps this correct for every resource's own
-    // partial-push semantics: a readonly option skipped by `option push`, a snippet or SEO
-    // redirect that gets a server-assigned id on create, a theme-styles push that only touches the
+    // partial-push semantics: a readonly option skipped by `option push`, a snippet or form
+    // that gets a server-assigned id on create, a theme-styles push that only touches the
     // active stylesheet, an API/hook push that leaves server-side files alone unless `--prune`.
     // `lps <resource> rollback`'s drift check compares the environment's state at rollback time
     // against exactly this after-state, so it has to be what actually landed, not what was sent.

package/dist/lib/put-or-create.js

@@ -1,8 +1,7 @@
 import { isNotFoundError } from './wp-client.js';
-// Update-or-create dance shared by every id-based resource (form, seo redirect,
-// snippet, unlike ACF which is key-based and only ever POSTs): PUT to the known id, and only
-// fall back to POST when the site doesn't recognize that id (404), e.g. a fresh install or a
-// database reset.
+// Update-or-create dance shared by every id-based resource (form, snippet, unlike ACF which
+// is key-based and only ever POSTs): PUT to the known id, and only fall back to POST when the
+// site doesn't recognize that id (404), e.g. a fresh install or a database reset.
 export async function putOrCreate(wp, options) {
     const { id, payload, postEndpoint, postPayload = payload, putEndpoint } = options;
     if (id !== null) {