@loopress/cli 0.29.0 → 0.31.0

package/dist/config/project-config.manager.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { LOCAL_ENVIRONMENT_NAME } from '../lib/wp-client.js';
 import { toSlug } from '../utils/to-slug.js';
 import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
@@ -39,15 +40,6 @@ export class ProjectConfigManager {
     getConfigFilePath() {
         return join(this.requireConfigDir(), 'config.json');
     }
-    getCurrentEnv() {
-        const config = this.readConfig();
-        if (!config.currentProject)
-            return null;
-        const project = config.projects[config.currentProject.id];
-        if (!project)
-            return null;
-        return project.environments[config.currentProject.env] ?? null;
-    }
     getCurrentProject() {
         const config = this.readConfig();
         if (!config.currentProject)
@@ -57,6 +49,17 @@ export class ProjectConfigManager {
             return null;
         return { ...project, id: config.currentProject.id };
     }
+    // The environment a command targets without --env: "local" when the project has one (where
+    // you work, so it's the safe default), otherwise its only environment. Null when the project
+    // has several remote ones and no local: the user must say which one with --env, since a
+    // remembered choice is exactly the hidden state that sends a push to the wrong site.
+    getDefaultEnvironment(projectId) {
+        const environments = this.getProject(projectId)?.environments ?? {};
+        const names = Object.keys(environments);
+        if (Object.hasOwn(environments, LOCAL_ENVIRONMENT_NAME))
+            return environments[LOCAL_ENVIRONMENT_NAME];
+        return names.length === 1 ? environments[names[0]] : null;
+    }
     getEnvironment(projectId, envName) {
         const project = this.getProject(projectId);
         if (!project)
@@ -71,14 +74,11 @@ export class ProjectConfigManager {
         return this.readConfig().telemetry?.disabled ?? false;
     }
     listEnvironments(projectId) {
-        const config = this.readConfig();
-        const project = config.projects[projectId];
+        const project = this.getProject(projectId);
         if (!project)
             return [];
-        return Object.values(project.environments).map((env) => ({
-            ...env,
-            isCurrent: config.currentProject?.id === projectId && config.currentProject.env === env.name,
-        }));
+        const defaultEnv = this.getDefaultEnvironment(projectId);
+        return Object.values(project.environments).map((env) => ({ ...env, isDefault: env.name === defaultEnv?.name }));
     }
     listProjects() {
         const config = this.readConfig();
@@ -101,10 +101,6 @@ export class ProjectConfigManager {
         if (!project)
             return;
         Reflect.deleteProperty(project.environments, envName);
-        if (config.currentProject?.id === projectId && config.currentProject.env === envName) {
-            const remaining = Object.keys(project.environments);
-            config.currentProject = remaining.length > 0 ? { env: remaining[0], id: projectId } : null;
-        }
         this.writeConfig(config);
     }
     removeProject(id) {
@@ -112,9 +108,7 @@ export class ProjectConfigManager {
         Reflect.deleteProperty(config.projects, id);
         if (config.currentProject?.id === id) {
             const [nextId] = Object.keys(config.projects);
-            const nextProject = nextId ? config.projects[nextId] : undefined;
-            const [nextEnv] = nextProject ? Object.keys(nextProject.environments) : [];
-            config.currentProject = nextId && nextEnv ? { env: nextEnv, id: nextId } : null;
+            config.currentProject = nextId ? { id: nextId } : null;
         }
         this.writeConfig(config);
     }
@@ -124,11 +118,11 @@ export class ProjectConfigManager {
     setConfigDir(configDir) {
         this.configDir = configDir;
     }
-    setCurrent(projectId, envName) {
+    setCurrent(projectId) {
         const config = this.readConfig();
         if (!Object.hasOwn(config.projects, projectId))
             return;
-        config.currentProject = { env: envName, id: projectId };
+        config.currentProject = { id: projectId };
         this.writeConfig(config);
     }
     setEnvironment(projectId, envName, env) {
@@ -137,7 +131,7 @@ export class ProjectConfigManager {
         if (!project)
             return;
         project.environments[envName] = env;
-        config.currentProject ??= { env: envName, id: projectId };
+        config.currentProject ??= { id: projectId };
         this.writeConfig(config);
     }
     setEnvironmentApiId(projectId, envName, apiEnvironmentId) {
@@ -151,11 +145,7 @@ export class ProjectConfigManager {
     setProject(id, project) {
         const config = this.readConfig();
         config.projects[id] = project;
-        if (!config.currentProject) {
-            const [firstEnv] = Object.keys(project.environments);
-            if (firstEnv)
-                config.currentProject = { env: firstEnv, id };
-        }
+        config.currentProject ??= { id };
         this.writeConfig(config);
     }
     setProjectApiId(id, apiProjectId) {
@@ -203,7 +193,8 @@ export class ProjectConfigManager {
         if (value === null || typeof value !== 'object')
             return null;
         const pointer = value;
-        return typeof pointer.id === 'string' && typeof pointer.env === 'string' ? { env: pointer.env, id: pointer.id } : null;
+        // A legacy `env` field, from when switch also picked the environment, is dropped here.
+        return typeof pointer.id === 'string' ? { id: pointer.id } : null;
     }
     sanitizeProjects(value) {
         if (typeof value !== 'object' || value === null)

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

@@ -14,6 +14,7 @@ export declare abstract class LoopressCommand extends Command {
     };
     protected dryRun: boolean;
     protected localConfig: LoopressLocalConfig;
+    protected overwrite: boolean;
     protected productionConfirmed: boolean;
     protected projectId: string;
     protected siteConfig: EnvironmentConfig;
@@ -39,10 +40,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 = {
@@ -26,6 +28,8 @@ export class LoopressCommand extends Command {
     };
     dryRun = false;
     localConfig = {};
+    // Set by PushCommand's --overwrite, see PushCommand.guardOutsideEdits.
+    overwrite = false;
     // Set by PushCommand's hidden --production-confirmed, see there.
     productionConfirmed = false;
     projectId;
@@ -56,6 +60,7 @@ export class LoopressCommand extends Command {
         }));
         this.dryRun = Boolean(flags['dry-run']);
         this.yes = Boolean(flags.yes);
+        this.overwrite = Boolean(flags.overwrite);
         this.productionConfirmed = Boolean(flags['production-confirmed']);
         this.localConfig = await readLocalConfig();
         const resolved = this.resolveEnvironment(flags.env);
@@ -107,13 +112,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 +172,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 +192,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 +208,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/diff-command.d.ts

@@ -23,6 +23,7 @@ export type DiffTarget = {
 type DiffSides = {
     againstWp: undefined | WpClient;
     leftLabel: string;
+    rightHeading: string;
     rightLabel: string;
     warn: (message: string) => void;
 };
@@ -37,6 +38,7 @@ export declare abstract class DiffCommand extends LoopressCommand {
     abstract run(): Promise<DiffJson>;
     private computeResource;
     private out;
+    private renderFailure;
     private renderSection;
     private wpForEnvironment;
 }