@loopress/cli 0.26.0 → 0.28.0

package/dist/commands/template/list.js

@@ -0,0 +1,23 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { pluralize } from '../../utils/pluralize.js';
+import { CHILD_THEME_ENDPOINT } from '../../utils/template-format.js';
+export default class List extends LoopressCommand {
+    static description = 'Show the Loopress child theme of the active block theme: its templates, parts, and those edited in the Site Editor';
+    static enableJsonFlag = true;
+    static examples = ['$ lps template list'];
+    async run() {
+        const child = await this.wp.get(CHILD_THEME_ENDPOINT);
+        // The markup is only needed by `template diff`, it would drown the JSON output here.
+        const result = { ...child, parts: child.parts.map((part) => part.slug), templates: child.templates.map((template) => template.slug) };
+        if (!child.exists) {
+            this.log(`No Loopress child theme yet (${child.stylesheet}), run lps template push.`);
+            return result;
+        }
+        this.log(`${child.stylesheet} (child of ${child.parent}, ${child.active ? 'active' : 'not active'})`);
+        this.log(`  ${pluralize(result.templates.length, 'template')}: ${result.templates.join(', ') || 'none'}`);
+        this.log(`  ${pluralize(result.parts.length, 'part')}: ${result.parts.join(', ') || 'none'}`);
+        if (child.customized.length > 0)
+            this.log(`  Edited in the Site Editor: ${child.customized.join(', ')}`);
+        return result;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { PushCommand } from '../../lib/push-command.js';
+type PushResult = {
+    active?: boolean;
+    customized?: string[];
+    parts: string[];
+    status: 'dry-run' | 'success';
+    stylesheet?: string;
+    templates: string[];
+};
+export default class Push extends PushCommand {
+    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<PushResult>;
+}
+export {};

package/dist/commands/template/push.js

@@ -0,0 +1,42 @@
+import { PushCommand } from '../../lib/push-command.js';
+import { formatPageProblems } from '../../utils/page-format.js';
+import { pluralize } from '../../utils/pluralize.js';
+import { resolveResourceDir } from '../../utils/resource-dirs.js';
+import { CHILD_THEME_ENDPOINT, readLocalTemplates } from '../../utils/template-format.js';
+export default class Push extends PushCommand {
+    static description = 'Push block templates (templates/<slug>.html) and template parts (parts/<slug>.html) as the files of a child theme of the active block theme, <parent>-loopress. The child mirrors the project: files removed locally are removed from it. It is never activated for you.';
+    static enableJsonFlag = true;
+    static examples = ['$ lps template push', '$ lps template push --dry-run'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        await this.parse(Push);
+        const templatesPath = resolveResourceDir('template', this.localConfig);
+        const partsPath = resolveResourceDir('part', this.localConfig);
+        this.log(`Pushing templates and parts to ${this.siteConfig.url}`);
+        this.log(`Templates path: ${templatesPath}, parts path: ${partsPath}`);
+        const { parts, problems, templates } = await readLocalTemplates(templatesPath, partsPath);
+        if (problems.length > 0) {
+            this.error(`Nothing was pushed, fix these files first:\n  ${formatPageProblems(problems)}`);
+        }
+        const names = { parts: parts.map((part) => part.slug), templates: templates.map((template) => template.slug) };
+        this.log(`Found ${pluralize(templates.length, 'template')} and ${pluralize(parts.length, 'part')}`);
+        if (this.dryRun) {
+            this.log('[dry-run] Would rewrite the child theme with them.');
+            return { ...names, status: 'dry-run' };
+        }
+        const child = await this.wp.put(CHILD_THEME_ENDPOINT, { parts, templates });
+        await this.recordSuccess();
+        this.log(`Child theme ${child.stylesheet} written.`);
+        if (!child.active) {
+            this.warn(`${child.stylesheet} is not the active theme, so nothing changed on the site yet. Activate it in Appearance > Themes.`);
+        }
+        if (child.customized.length > 0) {
+            this.warn(`Edited in the Site Editor, their database copy still wins over the pushed file: ${child.customized.join(', ')}. ` +
+                'Clear their customizations in Appearance > Editor to use the pushed version.');
+        }
+        return { ...names, active: child.active, customized: child.customized, status: 'success', stylesheet: child.stylesheet };
+    }
+}

package/dist/commands/theme/add.d.ts

@@ -1,13 +1,20 @@
 import { LoopressCommand } from '../../lib/base.js';
+type AddResult = {
+    slug: string;
+    status: 'added' | 'dry-run' | 'unchanged' | 'updated';
+    version: string;
+};
 export default class Add extends LoopressCommand {
     static args: {
         slug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
+    static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
         version: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    run(): Promise<void>;
+    run(): Promise<AddResult>;
 }
+export {};

package/dist/commands/theme/add.js

@@ -7,6 +7,7 @@ export default class Add extends LoopressCommand {
         slug: Args.string({ description: 'Theme slug on WordPress.org', required: true }),
     };
     static description = 'Add a WordPress.org theme to loopress.json';
+    static enableJsonFlag = true;
     static examples = ['$ lps theme add generatepress', '$ lps theme add generatepress --version 3.4.0'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
@@ -22,14 +23,15 @@ export default class Add extends LoopressCommand {
         const existing = this.localConfig.themes ?? {};
         if (existing[slug] === version) {
             this.log(`${slug} is already pinned to ${version}, nothing to do.`);
-            return;
+            return { slug, status: 'unchanged', version };
         }
         const isUpdated = existing[slug] !== undefined;
         if (this.dryRun) {
             this.log(`[dry-run] Would ${isUpdated ? 'update' : 'add'} ${slug} (${version})`);
-            return;
+            return { slug, status: 'dry-run', version };
         }
         await writeLocalConfig({ ...this.localConfig, themes: { ...existing, [slug]: version } });
         this.log(`${isUpdated ? 'Updated' : 'Added'} ${slug} (${version}). Run \`lps theme push\` to apply.`);
+        return { slug, status: isUpdated ? 'updated' : 'added', version };
     }
 }

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

@@ -1,8 +1,10 @@
 import { LoopressCommand } from '../../lib/base.js';
+import { type ComposerPullResult } from '../../utils/composer.js';
 type PullResult = {
     added: string[];
     merged: Record<string, string>;
-    status: 'composer-managed' | 'dry-run' | 'success';
+    skipped?: ComposerPullResult['skipped'];
+    status: 'dry-run' | 'success';
     updated: Array<{
         from: string;
         slug: string;

package/dist/commands/theme/pull.js

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { pullIntoComposerJson } from '../../utils/composer.js';
 import { writeLocalConfig } from '../../utils/loopress-config.js';
 import { mergePluginManifest } from '../../utils/plugins.js';
 import { parseInstalledThemes } from '../../utils/themes.js';
@@ -13,14 +14,19 @@ export default class Pull extends LoopressCommand {
     };
     async run() {
         const { url } = this.siteConfig;
-        if (existsSync(join(process.cwd(), this.rootDir, 'composer.json'))) {
-            this.warn('This project has a composer.json, which is authoritative. Run `lps composer pull` instead.');
-            return { added: [], merged: this.localConfig.themes ?? {}, status: 'composer-managed', updated: [] };
-        }
         this.log(`Pulling themes from ${url}`);
         const raw = await this.wp.get('wp/v2/themes');
         const installed = parseInstalledThemes(raw);
         const incoming = Object.fromEntries(installed.map((t) => [t.slug, t.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)) {
+            const result = await pullIntoComposerJson(composerJsonPath, 'theme', incoming, {
+                dryRun: this.dryRun,
+                log: this.log.bind(this),
+            });
+            return { ...result, status: this.dryRun ? 'dry-run' : 'success' };
+        }
         const { added, merged, updated } = mergePluginManifest(this.localConfig.themes ?? {}, incoming);
         if (this.dryRun) {
             this.log(`[dry-run] Would write ${Object.keys(merged).length} themes to loopress.json`);

package/dist/commands/theme/style/diff.d.ts

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

package/dist/commands/{theme-styles → theme/style}/diff.js

@@ -1,5 +1,6 @@
-import { resourceDiffCommand } from '../../lib/diff-command.js';
+import { resourceDiffCommand } from '../../../lib/diff-command.js';
 export default resourceDiffCommand('theme-styles', {
     description: "Show what differs in the active block theme's Global Styles (Site Editor > Styles) between your local file and a WordPress environment, or between two environments",
+    command: 'theme style',
     pathNoun: 'theme styles directory',
 });

package/dist/commands/{theme-styles → theme/style}/pull.d.ts

@@ -1,4 +1,4 @@
-import { LoopressCommand } from '../../lib/base.js';
+import { LoopressCommand } from '../../../lib/base.js';
 export default class Pull extends LoopressCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/{theme-styles → theme/style}/pull.js

@@ -1,14 +1,14 @@
 import { Args } from '@oclif/core';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { LoopressCommand } from '../../lib/base.js';
-import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName, } from '../../utils/theme-styles-format.js';
+import { LoopressCommand } from '../../../lib/base.js';
+import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName, } from '../../../utils/theme-styles-format.js';
 export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
     };
     static description = "Pull the active block theme's Global Styles customizations (Site Editor > Styles) from WordPress into a local file";
-    static examples = ['$ lps theme-styles pull'];
+    static examples = ['$ lps theme style pull'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
     };

package/dist/commands/{theme-styles → theme/style}/push.d.ts

@@ -1,4 +1,4 @@
-import { PushCommand } from '../../lib/push-command.js';
+import { PushCommand } from '../../../lib/push-command.js';
 export default class Push extends PushCommand {
     static args: {
         path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/{theme-styles → theme/style}/push.js

@@ -1,15 +1,15 @@
 import { Args } from '@oclif/core';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { PushCommand } from '../../lib/push-command.js';
-import { getResourceStateProvider } from '../../lib/resource-state.js';
-import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../utils/theme-styles-format.js';
+import { PushCommand } from '../../../lib/push-command.js';
+import { getResourceStateProvider } from '../../../lib/resource-state.js';
+import { getActiveThemeGlobalStyles, globalStylesEndpoint, themeStylesFileName } from '../../../utils/theme-styles-format.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to theme styles directory (overrides project config)' }),
     };
     static description = "Push the local Global Styles file to the active block theme's Site Editor > Styles on WordPress";
-    static examples = ['$ lps theme-styles push'];
+    static examples = ['$ lps theme style push'];
     static flags = {
         ...PushCommand.dryRunFlag,
     };
@@ -26,7 +26,7 @@ export default class Push extends PushCommand {
         }
         catch (error) {
             if (error.code === 'ENOENT') {
-                this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme-styles pull\` first.`);
+                this.error(`No local Global Styles file found for the active theme ("${file}"). Run \`lps theme style pull\` first.`);
             }
             throw error;
         }

package/dist/commands/theme/style/rollback.d.ts

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

package/dist/commands/theme/style/rollback.js

@@ -0,0 +1,6 @@
+import { resourceRollbackCommand } from '../../../lib/rollback-command.js';
+export default resourceRollbackCommand('theme-styles', {
+    description: "Restore the active theme's Global Styles to a snapshot taken automatically before an earlier `lps theme style push`",
+    command: 'theme style',
+    pathNoun: 'theme styles directory',
+});

package/dist/lib/api-client.js

@@ -43,11 +43,36 @@ function formatApiError(error, url, timeoutMs) {
     if (status === 401) {
         return `Not logged in or session expired on ${url}. Run \`lps login\` again.`;
     }
+    const reason = nestErrorMessage(err.response?.body);
     if (status === 403) {
-        return `Request rejected (${status}) on ${url}: ${err.response?.body ?? err.message}`;
+        // An empty body (not just a missing one) falls back to got's message too, never a bare ": ".
+        const body = err.response?.body === '' ? undefined : err.response?.body;
+        return `Request rejected (${status}) on ${url}: ${reason ?? body ?? err.message}`;
+    }
+    // Any other API refusal (a 400 validation error, a 409 conflict) carries its explanation in
+    // the body; got's own message ("Request failed with status code 400") never does.
+    if (status !== undefined && reason) {
+        return `Request failed (${status}) on ${url}: ${reason}`;
     }
     if (err.name === 'TimeoutError') {
         return `Request timed out after ${timeoutMs / 1000}s on ${url}. Check your network connection, or the Loopress API may be temporarily unreachable.`;
     }
     return err.message ?? String(error);
 }
+// NestJS's HttpException body: `{statusCode, message, error}`, where `message` is a list for a
+// ValidationPipe failure (one entry per invalid field).
+function nestErrorMessage(body) {
+    if (!body)
+        return undefined;
+    try {
+        const { message } = JSON.parse(body);
+        if (typeof message === 'string' && message.trim())
+            return message;
+        if (Array.isArray(message) && message.length > 0)
+            return message.join('; ');
+    }
+    catch {
+        // not JSON (a proxy's HTML error page): nothing to extract
+    }
+    return undefined;
+}

package/dist/lib/app-build.d.ts

@@ -0,0 +1,5 @@
+declare const PACKAGE_MANAGERS: readonly ["bun", "npm", "pnpm", "yarn"];
+type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare function detectPackageManager(appDir: string, packageManagerField?: string): PackageManager;
+export declare function buildApp(appDir: string, onStart?: (command: string) => void): Promise<string | undefined>;
+export {};

package/dist/lib/app-build.js

@@ -0,0 +1,69 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+// 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'];
+const LOCKFILES = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['bun.lock', 'bun'],
+    ['bun.lockb', 'bun'],
+    ['package-lock.json', 'npm'],
+];
+// How many trailing lines of build output a failure message carries.
+const OUTPUT_TAIL_LINES = 20;
+// `packageManager` field first (corepack's own source of truth), then the nearest lockfile
+// walking up to the repository root (an app inside a workspace shares the root lockfile),
+// then npm.
+export function detectPackageManager(appDir, packageManagerField) {
+    const fromField = packageManagerField?.split('@', 1)[0];
+    if (PACKAGE_MANAGERS.includes(fromField))
+        return fromField;
+    for (let dir = appDir;; dir = dirname(dir)) {
+        const lockfile = LOCKFILES.find(([file]) => existsSync(join(dir, file)));
+        if (lockfile)
+            return lockfile[1];
+        if (existsSync(join(dir, '.git')) || dirname(dir) === dir)
+            return 'npm';
+    }
+}
+// Runs the app's own `build` script, if its package.json declares one. Returns the command it
+// ran, or undefined when there is nothing to build (no package.json, or no build script: the
+// dist/ folder is then taken as is). Throws with the tail of the output when the build fails,
+// so a broken build never ships the stale dist/ left over from the previous one.
+export async function buildApp(appDir, onStart) {
+    const packageJsonPath = join(appDir, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return undefined;
+    const pkg = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    if (!pkg.scripts?.build)
+        return undefined;
+    const pm = detectPackageManager(appDir, pkg.packageManager);
+    const command = `${pm} run build`;
+    onStart?.(command);
+    const { code, output } = await 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' });
+        let out = '';
+        const collect = (chunk) => {
+            out += chunk;
+        };
+        child.stdout.setEncoding('utf8').on('data', collect);
+        child.stderr.setEncoding('utf8').on('data', collect);
+        child.on('error', reject);
+        child.on('close', (exitCode) => {
+            resolve({ code: exitCode, output: out });
+        });
+    });
+    if (code !== 0) {
+        const tail = output.trimEnd().split('\n').slice(-OUTPUT_TAIL_LINES).join('\n');
+        const hint = existsSync(join(appDir, 'node_modules'))
+            ? ''
+            : `\nnode_modules is missing: run \`${pm} install\` in ${appDir} first.`;
+        throw new Error(`\`${command}\` failed (exit code ${code}):\n${tail}${hint}`);
+    }
+    return command;
+}

package/dist/lib/app-manifest.d.ts

@@ -7,8 +7,11 @@ export type AppEntry = {
     scripts: string[];
     styles: string[];
 };
+export declare const CROSS_ORIGIN_POLICIES: readonly ["same-origin", "same-site"];
+export type CrossOriginPolicy = (typeof CROSS_ORIGIN_POLICIES)[number];
 export type AppConfigFile = {
     assetsDir?: string;
+    crossOrigin?: CrossOriginPolicy;
     entry?: AppEntry;
     mountSelector?: string;
     name?: string;
@@ -16,6 +19,7 @@ export type AppConfigFile = {
 };
 export type AppManifest = {
     buildId: string;
+    crossOrigin?: CrossOriginPolicy;
     entry: AppEntry;
     files: AppFile[];
     mountSelector: string;

package/dist/lib/app-manifest.js

@@ -2,6 +2,9 @@ import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
 import { walkFiles } from './readdir-tolerant.js';
+// Cross-Origin-Resource-Policy the server sends with the app's files. Mirrors the server's
+// AppManifest::SUPPORTED_CROSS_ORIGIN; `cross-origin` is the browser default, i.e. the field unset.
+export const CROSS_ORIGIN_POLICIES = ['same-origin', 'same-site'];
 export const APP_CONFIG_FILENAME = 'loopress.app.json';
 const DEFAULT_ASSETS_DIR = 'dist';
 // Static assets a bundler emits, mirrors the server's AppsDirectory::ALLOWED_EXTENSIONS.
@@ -89,6 +92,10 @@ export function parseAppConfig(raw, appDir) {
     if (config.routing !== undefined && config.routing !== 'hash') {
         throw new Error(`${join(appDir, APP_CONFIG_FILENAME)}: routing "${config.routing}" is not supported, only "hash" works without a server rewrite`);
     }
+    if (config.crossOrigin !== undefined && !CROSS_ORIGIN_POLICIES.includes(config.crossOrigin)) {
+        const supported = CROSS_ORIGIN_POLICIES.map((policy) => JSON.stringify(policy)).join(' or ');
+        throw new Error(`${join(appDir, APP_CONFIG_FILENAME)}: crossOrigin "${config.crossOrigin}" is not supported, use ${supported}`);
+    }
     return config;
 }
 // Assembles the full manifest for one app directory: reads loopress.app.json, hashes the
@@ -129,6 +136,7 @@ export async function loadAppManifest(appDir, dirName) {
         distDir,
         manifest: {
             buildId: computeBuildId(files),
+            ...(config.crossOrigin && { crossOrigin: config.crossOrigin }),
             entry,
             files,
             mountSelector: config.mountSelector ?? `#loopress-app-${name}`,

package/dist/lib/base.js

@@ -35,11 +35,11 @@ export class LoopressCommand extends Command {
     }
     get wp() {
         if (!this.wpClient) {
-            const { token, url } = this.siteConfig;
+            const { name, token, url } = this.siteConfig;
             if (!token) {
                 this.error(`No credentials configured for ${url}. Run \`lps project config\` to add them.`);
             }
-            this.wpClient = new WpClient(url, token);
+            this.wpClient = new WpClient(url, token, name);
         }
         return this.wpClient;
     }
@@ -65,12 +65,21 @@ export class LoopressCommand extends Command {
     // `dryRun` is excluded since rotating writes a new credential, a real side effect a
     // --dry-run run promises not to cause. `Rotate` overrides this to a no-op: its own `run()`
     // already rotates unconditionally, so the background check would only redo the same work.
+    // CI is excluded too: rotating revokes the old password, but a runner's config.json (a CI
+    // secret copy) is thrown away at the end of the job, so every later run would get a 401.
     async maybeAutoRotate() {
         if (this.dryRun)
             return;
         const { token } = this.siteConfig;
         if (!token || !isAppPasswordStale(this.siteConfig.addedAt))
             return;
+        // Set by `lps promote --dry-run` around its delegated pull: a preview must not revoke anything.
+        if (process.env.LOOPRESS_NO_AUTO_ROTATE)
+            return;
+        if (process.env.CI) {
+            this.warn(`The app password for "${this.siteConfig.name}" is older than 90 days. Auto-rotation is skipped in CI, run \`lps project rotate\` where this config.json lives, then update the CI secret.`);
+            return;
+        }
         try {
             const rotated = await rotateAppPassword({ ...this.siteConfig, token });
             this.siteConfig = rotated;

package/dist/lib/bootstrap-full-install.js

@@ -14,24 +14,55 @@ export async function bootstrapLoopressFull(wp, siteUrl, log) {
     const zipPath = await downloadLatestFullZip();
     log('Creating a temporary admin account to install it...');
     const admin = await createTempAdmin(wp);
+    // The temp account is a real administrator; it must never outlive this function, including
+    // when the process is interrupted mid-install (Ctrl-C, or a hung/killed headless browser).
+    // removeTempAdmin() memoises a single deletion so the normal path and either signal handler
+    // all await the same in-flight promise instead of racing or deleting twice.
+    let cleanupPromise;
+    const removeTempAdmin = async () => {
+        cleanupPromise ??= deleteTempAdmin(wp, admin);
+        return cleanupPromise;
+    };
+    const onSignal = (signal) => {
+        // Finish (or start) the deletion, surface a manual-removal hint if it fails since the normal
+        // error path below won't run, then re-raise the signal with our handler gone so Node's
+        // default termination runs with the right exit code.
+        removeTempAdmin()
+            .catch((error) => {
+            log(`Could not remove the temporary admin account "${admin.username}"; remove it manually in wp-admin. (${error.message})`);
+        })
+            .finally(() => {
+            process.removeListener('SIGINT', onSignal);
+            process.removeListener('SIGTERM', onSignal);
+            process.kill(process.pid, signal);
+        });
+    };
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
     let installError;
-    try {
-        log('Installing and activating Loopress Full...');
-        await runBrowserInstall(admin, siteUrl, zipPath);
-    }
-    catch (error) {
-        installError = error;
-    }
-    if (!installError) {
-        log('Loopress Full installed and activated.');
-    }
-    log('Removing the temporary admin account...');
     let cleanupError;
     try {
-        await deleteTempAdmin(wp, admin);
+        try {
+            log('Installing and activating Loopress Full...');
+            await runBrowserInstall(admin, siteUrl, zipPath);
+            log('Loopress Full installed and activated.');
+        }
+        catch (error) {
+            installError = error;
+        }
+        log('Removing the temporary admin account...');
+        try {
+            await removeTempAdmin();
+        }
+        catch (error) {
+            cleanupError = error;
+        }
     }
-    catch (error) {
-        cleanupError = error;
+    finally {
+        // Only stop guarding once the deletion has settled: a signal during the removal above must
+        // still trigger (or await) cleanup rather than terminating the process with the account live.
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
     }
     const manualFallback = `Install it manually: upload ${zipPath} at ${siteUrl}/wp-admin/plugin-install.php?tab=upload`;
     if (installError && cleanupError) {

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

@@ -1,5 +1,5 @@
 import { type LoopressLocalConfig } from '../utils/loopress-config.js';
-export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
+export type ResourceType = 'api' | '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,6 @@
 import { existsSync } from 'node:fs';
 import { join, sep } from 'node:path';
-export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
+export const RESOURCE_TYPES = ['snippets', 'templates', 'parts', '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,8 +15,11 @@ 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' },
+        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: 'template:push', path: join(rootDir, localConfig.partDir ?? 'parts'), type: 'parts' },
+        templates: { commandId: 'template:push', path: join(rootDir, localConfig.templateDir ?? 'templates'), type: 'templates' },
         snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
     };
     return types

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

@@ -41,6 +41,7 @@ export declare abstract class DiffCommand extends LoopressCommand {
     private wpForEnvironment;
 }
 export declare function resourceDiffCommand(resource: string, options: {
+    command?: string;
     description: string;
     pathNoun: string;
 }): typeof DiffCommand;

package/dist/lib/diff-command.js

@@ -143,12 +143,14 @@ export class DiffCommand extends LoopressCommand {
         if (!env.token) {
             this.error(`No credentials configured for "${envName}". Run \`lps project config\` to add them.`);
         }
-        return new WpClient(env.url, env.token);
+        return new WpClient(env.url, env.token, env.name);
     }
 }
 // Builds the `lps <resource> diff` command class for one directory-backed resource. They differ
 // only in wording and which provider they target, so the whole body lives here.
+// `command` is the CLI topic when it isn't the resource key (e.g. `theme style` for theme-styles).
 export function resourceDiffCommand(resource, options) {
+    const command = options.command ?? resource;
     class ResourceDiff extends DiffCommand {
         static args = {
             path: Args.string({ description: `Path to ${options.pathNoun} (overrides project config)` }),
@@ -156,9 +158,9 @@ export function resourceDiffCommand(resource, options) {
         static description = options.description;
         static enableJsonFlag = true;
         static examples = [
-            `$ lps ${resource} diff`,
-            `$ lps ${resource} diff --env staging`,
-            `$ lps ${resource} diff --env staging --against production`,
+            `$ lps ${command} diff`,
+            `$ lps ${command} diff --env staging`,
+            `$ lps ${command} diff --env staging --against production`,
         ];
         static flags = { ...DiffCommand.againstFlag };
         async run() {

package/dist/lib/json-delegation.d.ts

@@ -0,0 +1 @@
+export declare function stdoutToStderr<T>(enabled: boolean, work: () => Promise<T>): Promise<T>;

package/dist/lib/json-delegation.js

@@ -0,0 +1,18 @@
+// `lps push`/`pull`/`promote --json` must put exactly one JSON document on stdout: that's what
+// the MCP server (and any script) parses. The resource commands they delegate to aren't in JSON
+// mode themselves, so their progress lines and Listr renderers would land on stdout ahead of it.
+// While `enabled`, their stdout goes to stderr instead: still visible to a human, out of the
+// JSON. Patching the stream's write is the one place every writer goes through (oclif's
+// ux.stdout, Listr's renderers, a stray console.log).
+export async function stdoutToStderr(enabled, work) {
+    if (!enabled)
+        return work();
+    const original = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    try {
+        return await work();
+    }
+    finally {
+        process.stdout.write = original;
+    }
+}