@loopress/cli 0.18.0 → 0.20.0

package/dist/commands/form/pull.js

@@ -1,10 +1,11 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
-import slugify from 'slugify';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { findOrphanedFiles, numericPrefixKey } from '../../lib/find-orphaned-files.js';
 import { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
+import { toSlug } from '../../utils/to-slug.js';
 export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
@@ -13,6 +14,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps form pull'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Pull);
@@ -23,7 +25,12 @@ export default class Pull extends LoopressCommand {
         const remoteList = await this.wp.get(FORM_ENDPOINT);
         const withId = remoteList.filter((form) => getFormId(form) !== null);
         const skipped = remoteList.length - withId.length;
-        const orphans = await this.findOrphanedFiles(path, new Set(withId.map((form) => getFormId(form))));
+        // Only matches files following the `<id>-<slug>.json` convention pull/push themselves
+        // produce, same principle as `snippet pull`.
+        const orphans = await findOrphanedFiles(path, new Set(withId.map((form) => String(getFormId(form)))), {
+            extensions: ['.json'],
+            key: numericPrefixKey,
+        });
         if (this.dryRun) {
             this.log(`[dry-run] Would pull ${withId.length} form${withId.length === 1 ? '' : 's'} to ${path}`);
             if (orphans.length > 0) {
@@ -38,42 +45,16 @@ export default class Pull extends LoopressCommand {
             const title = getFormTitle(form);
             return {
                 async task(_ctx, task) {
-                    await writeFile(join(path, `${id}-${slug(title)}.json`), JSON.stringify(form, null, 2) + '\n');
+                    await writeFile(join(path, `${id}-${toSlug(title, 'untitled')}.json`), JSON.stringify(form, null, 2) + '\n');
                     task.output = `Pulled: ${title}`;
                 },
                 title: `Pull ${title}`,
             };
         })).run();
-        for (const file of orphans)
-            await rm(join(path, file), { force: true });
-        if (orphans.length > 0) {
-            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${path} no longer present on WordPress: ${orphans.join(', ')}`);
-        }
+        await this.removeOrphanedFiles(path, orphans, `in ${path} no longer present on WordPress`);
         this.log(`Pulled ${withId.length} form${withId.length === 1 ? '' : 's'} to ${path}`);
         if (skipped > 0) {
             this.warn(`${skipped} form${skipped === 1 ? '' : 's'} skipped because they have no id`);
         }
     }
-    // Only matches files following the `<id>-<slug>.json` convention pull/push themselves
-    // produce, same principle as findOrphanedFiles in commands/snippet/pull.ts.
-    async findOrphanedFiles(dir, keepIds) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        return files.filter((file) => {
-            if (extname(file) !== '.json')
-                return false;
-            const match = /^(\d+)-/.exec(file);
-            return match !== null && !keepIds.has(Number(match[1]));
-        });
-    }
-}
-export function slug(title) {
-    return slugify(title, { lower: true, strict: true }) || 'untitled';
 }

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

@@ -6,9 +6,9 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<void>;
     private ensureCanonicalFilename;
     private loadFiles;

package/dist/commands/form/push.js

@@ -5,7 +5,7 @@ import { dirname, extname, join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
 import { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
-import { slug } from './pull.js';
+import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
@@ -14,8 +14,8 @@ export default class Push extends PushCommand {
     static examples = ['$ lps form push'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
-    failedCount = 0;
     async run() {
         const { args } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -41,7 +41,7 @@ export default class Push extends PushCommand {
     // a title change in the WordPress admin), same principle as ensureCanonicalFilename in
     // commands/snippet/push.ts.
     async ensureCanonicalFilename(filePath, id, title) {
-        const canonicalPath = join(dirname(filePath), `${id}-${slug(title)}.json`);
+        const canonicalPath = join(dirname(filePath), `${id}-${toSlug(title, 'untitled')}.json`);
         if (filePath !== canonicalPath)
             await rename(filePath, canonicalPath);
     }
@@ -79,10 +79,8 @@ export default class Push extends PushCommand {
         }
         return forms;
     }
-    // Throwing on failure (rather than returning a boolean) is what lets Listr mark the task as
-    // failed (red cross) instead of completed; `exitOnError: false` on the task list still lets
-    // sibling forms push regardless. PUT-then-404-fallback-POST is the same dance as
-    // commands/snippet/push.ts, forms are id-based like snippets, not key-based like ACF.
+    // PUT-then-404-fallback-POST is the same dance as commands/snippet/push.ts, forms are
+    // id-based like snippets, not key-based like ACF.
     async pushForm(filePath, data, task) {
         const title = getFormTitle(data);
         if (this.dryRun) {
@@ -118,13 +116,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${title}`;
         }
         catch (error) {
-            const message = `Failed to push ${title}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${title}: ${error.message}`, error, task);
         }
     }
 }

package/dist/commands/init.d.ts

@@ -3,4 +3,6 @@ export default class Init extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private promptManualProjectId;
+    private resolveProjectChoice;
 }

package/dist/commands/init.js

@@ -1,8 +1,9 @@
-import { confirm, input, select } from '@inquirer/prompts';
+import { checkbox, confirm, input, select } from '@inquirer/prompts';
 import { Command } from '@oclif/core';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
+import { isInteractive } from '../lib/interactive.js';
 import { writeLocalConfig } from '../utils/loopress-config.js';
 // WordPress.org slugs for the two snippet plugins the Loopress WordPress plugin supports
 // (see SnippetModule.php, which wires up both providers and auto-detects the active one).
@@ -10,11 +11,22 @@ const SNIPPET_PROVIDERS = [
     { name: 'Code Snippets', slug: 'code-snippets' },
     { name: 'WPCode', slug: 'insert-headers-and-footers' },
 ];
+// Default directory per optional feature, matching the resolve*Path defaults in lib/base.ts.
+const FEATURES = [
+    { dir: 'acf', key: 'acfDir', label: 'ACF' },
+    { dir: 'seo', key: 'seoDir', label: 'SEO' },
+    { dir: 'forms', key: 'formDir', label: 'Forms' },
+    { dir: 'pages', key: 'pageDir', label: 'Pages' },
+    { dir: 'api', key: 'apiDir', label: 'Custom API routes' },
+];
 export default class Init extends Command {
     static description = 'Initialize a loopress.json config file in the current directory';
     static examples = ['$ lps init'];
     async run() {
         await this.parse(Init);
+        if (!isInteractive()) {
+            this.error('lps init asks its questions interactively and needs a terminal. In CI or scripts, commit a loopress.json instead (see the Getting Started documentation for the file format).');
+        }
         const configPath = join(process.cwd(), 'loopress.json');
         if (existsSync(configPath)) {
             const overwrite = await confirm({
@@ -26,38 +38,7 @@ export default class Init extends Command {
                 return;
             }
         }
-        const projects = configManager.listProjects();
-        let projectId;
-        let projectLabel;
-        if (projects.length > 0) {
-            const choices = [
-                ...projects.map((p) => ({ name: p.name, value: p.id })),
-                { name: 'Enter a project ID manually', value: '__manual__' },
-            ];
-            const choice = await select({
-                choices,
-                message: 'WordPress project',
-            });
-            if (choice === '__manual__') {
-                projectId = await input({
-                    message: 'Project ID',
-                    validate: (value) => (value.trim().length > 0 ? true : 'Project ID cannot be empty'),
-                });
-                projectLabel = projectId;
-            }
-            else {
-                projectId = choice;
-                projectLabel = projects.find((p) => p.id === choice).name;
-            }
-        }
-        else {
-            this.log('No projects configured yet. Run `lps project config` to add one first.');
-            projectId = await input({
-                message: 'Project ID',
-                validate: (value) => (value.trim().length > 0 ? true : 'Project ID cannot be empty'),
-            });
-            projectLabel = projectId;
-        }
+        const { projectId, projectLabel } = await this.resolveProjectChoice();
         const rootDir = await input({
             default: '.',
             message: 'Root directory',
@@ -66,6 +47,10 @@ export default class Init extends Command {
             default: 'snippets',
             message: 'Snippets directory (relative to root)',
         });
+        const features = await checkbox({
+            choices: FEATURES.map((feature) => ({ name: `${feature.label} (${feature.dir}/)`, value: feature.key })),
+            message: 'Other features to configure directories for (optional)',
+        });
         const providerChoice = await select({
             choices: [...SNIPPET_PROVIDERS.map((p) => ({ name: p.name, value: p.slug })), { name: 'None / already installed', value: '__none__' }],
             message: 'Snippet provider',
@@ -75,6 +60,10 @@ export default class Init extends Command {
             rootDir,
             snippetsDir,
         };
+        for (const feature of FEATURES) {
+            if (features.includes(feature.key))
+                config[feature.key] = feature.dir;
+        }
         await writeLocalConfig(config);
         let providerAdded = false;
         if (providerChoice !== '__none__') {
@@ -89,8 +78,51 @@ export default class Init extends Command {
         this.log(`\n✓ loopress.json created`);
         this.log(`  Project:  ${projectLabel}`);
         this.log(`  Snippets: ${join(rootDir, snippetsDir)}`);
+        for (const feature of FEATURES) {
+            if (features.includes(feature.key)) {
+                this.log(`  ${feature.label}:${' '.repeat(Math.max(1, 9 - feature.label.length))}${join(rootDir, feature.dir)}`);
+            }
+        }
         if (providerAdded) {
             this.log(`  Plugin:   ${providerChoice}`);
         }
+        this.log('\n→ Next: run `lps snippet pull` to fetch what is already on the site, or `lps doctor` to verify the connection.');
+    }
+    // When nothing is configured yet, the useful path is configuring a project right here, not
+    // typing a project ID that points at nothing. Manual entry stays available as an explicit
+    // choice, and as the fallback when the inline `project config` is declined or aborted.
+    async promptManualProjectId() {
+        const projectId = await input({
+            message: 'Project ID',
+            validate: (value) => (value.trim().length > 0 ? true : 'Project ID cannot be empty'),
+        });
+        return { projectId, projectLabel: projectId };
+    }
+    async resolveProjectChoice() {
+        let projects = configManager.listProjects();
+        if (projects.length === 0) {
+            this.log('No projects configured yet.');
+            const runConfig = await confirm({ default: true, message: 'Run `lps project config` now to add one?' });
+            if (!runConfig) {
+                return this.promptManualProjectId();
+            }
+            await this.config.runCommand('project:config');
+            projects = configManager.listProjects();
+            if (projects.length === 0) {
+                this.log('Still no project configured, falling back to manual entry.');
+                return this.promptManualProjectId();
+            }
+            if (projects.length === 1) {
+                return { projectId: projects[0].id, projectLabel: projects[0].name };
+            }
+        }
+        const choice = await select({
+            choices: [...projects.map((p) => ({ name: p.name, value: p.id })), { name: 'Enter a project ID manually', value: '__manual__' }],
+            message: 'WordPress project',
+        });
+        if (choice === '__manual__') {
+            return this.promptManualProjectId();
+        }
+        return { projectId: choice, projectLabel: projects.find((p) => p.id === choice).name };
     }
 }

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

@@ -0,0 +1,9 @@
+import { LoopressCommand } from '../../lib/base.js';
+export default class List extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/page/list.js

@@ -0,0 +1,26 @@
+import { Flags } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { getPageId, getPageTitle, PAGE_ENDPOINT, PAGE_LIST_QUERY } from '../../utils/page-format.js';
+export default class List extends LoopressCommand {
+    static description = 'List pages from WordPress';
+    static examples = ['$ lps page list'];
+    static flags = {
+        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const pages = await this.wp.get(`${PAGE_ENDPOINT}?${PAGE_LIST_QUERY}`);
+        if (flags.json) {
+            this.log(JSON.stringify(pages, null, 2));
+            return;
+        }
+        this.log(`Pages (${pages.length}):`);
+        if (pages.length === 0) {
+            this.log('  (none)');
+            return;
+        }
+        for (const page of pages) {
+            this.log(`  ${getPageId(page) ?? '(no id)'}. ${getPageTitle(page)}`);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/page/pull.js

@@ -0,0 +1,65 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+import { findOrphanedFiles, numericPrefixKey } from '../../lib/find-orphaned-files.js';
+import { getPageContent, getPageId, getPageTitle, PAGE_ENDPOINT, PAGE_LIST_QUERY, pageFileBase, pickPageMeta } from '../../utils/page-format.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to pages directory (overrides project config)' }),
+    };
+    static description = 'Pull pages from WordPress';
+    static examples = ['$ lps page pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolvePagePath(args.path);
+        this.log(`Pulling pages from ${url}`);
+        this.log(`Pages path: ${path}`);
+        // context=edit returns title/content/excerpt as raw editable source instead of rendered
+        // HTML, needed for the file to be a faithful, re-pushable copy (requires edit_pages).
+        const remoteList = await this.wp.get(`${PAGE_ENDPOINT}?${PAGE_LIST_QUERY}&context=edit`);
+        const withId = remoteList.filter((page) => getPageId(page) !== null);
+        const skipped = remoteList.length - withId.length;
+        // Every page writes an `.html` (content) and `.json` (everything else) pair; both
+        // extensions are candidates for orphan cleanup, same principle as `snippet pull`.
+        const orphans = await findOrphanedFiles(path, new Set(withId.map((page) => String(getPageId(page)))), {
+            extensions: ['.json', '.html'],
+            key: numericPrefixKey,
+        });
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${withId.length} page${withId.length === 1 ? '' : 's'} to ${path}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${path} no longer present on WordPress: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        if (withId.length > 0)
+            await mkdir(path, { recursive: true });
+        await new Listr(withId.map((page) => {
+            const id = getPageId(page);
+            const title = getPageTitle(page);
+            return {
+                async task(_ctx, task) {
+                    const base = pageFileBase(id, title);
+                    // `content` lives entirely in the `.html` file; the `.json` sidecar keeps only the
+                    // fields WordPress actually accepts back on write, see pickPageMeta.
+                    await writeFile(join(path, `${base}.html`), getPageContent(page));
+                    await writeFile(join(path, `${base}.json`), JSON.stringify(pickPageMeta(page), null, 2) + '\n');
+                    task.output = `Pulled: ${title}`;
+                },
+                title: `Pull ${title}`,
+            };
+        })).run();
+        await this.removeOrphanedFiles(path, orphans, `in ${path} no longer present on WordPress`);
+        this.log(`Pulled ${withId.length} page${withId.length === 1 ? '' : 's'} to ${path}`);
+        if (skipped > 0) {
+            this.warn(`${skipped} page${skipped === 1 ? '' : 's'} skipped because they have no id`);
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+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>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private ensureCanonicalFilename;
+    private loadFiles;
+    private pushPage;
+}

package/dist/commands/page/push.js

@@ -0,0 +1,145 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import { PushCommand } from '../../lib/push-command.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { getPageId, getPageTitle, PAGE_ENDPOINT, pageFileBase } from '../../utils/page-format.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to pages directory (overrides project config)' }),
+    };
+    static description = 'Push pages to WordPress. Local files created or updated remotely are renamed on disk to the `<id>-<slug>` convention.';
+    static examples = ['$ lps page push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolvePagePath(args.path);
+        this.log(`Pushing pages to ${url}`);
+        this.log(`Pages path: ${path}`);
+        const pages = await this.loadFiles(path);
+        this.log(`Found ${pages.length} page${pages.length === 1 ? '' : 's'} to push`);
+        await new Listr(pages.map((page) => ({
+            task: async (_ctx, task) => this.pushPage(page, task),
+            title: `Push ${getPageTitle(page.meta)}`,
+        })), { concurrent: false, exitOnError: false }).run();
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} page${this.failedCount === 1 ? '' : 's'} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All pages pushed.');
+    }
+    // Renames the local file pair to the `<id>-<slug>` convention used by `page pull` whenever it
+    // doesn't already match, same principle as ensureCanonicalFilename in commands/snippet/push.ts:
+    // the id is persisted into the sidecar before any rename, so a crash mid-rename still leaves a
+    // valid, matchable pair on disk instead of an orphaned one that would be recreated as a duplicate.
+    async ensureCanonicalFilename(page, id, title) {
+        const dir = dirname(page.contentPath);
+        const canonicalBase = pageFileBase(id, title);
+        const currentBase = basename(page.contentPath, '.html');
+        const meta = { ...page.meta, id };
+        await writeFile(page.metaPath, JSON.stringify(meta, null, 2) + '\n');
+        if (currentBase === canonicalBase)
+            return;
+        await rename(page.contentPath, join(dir, `${canonicalBase}.html`));
+        await rename(page.metaPath, join(dir, `${canonicalBase}.json`));
+    }
+    // A page is its `.html` content file plus an optional `.json` sidecar for everything else
+    // (a fresh hand-created page may have no sidecar yet). One page is read in isolation: a
+    // corrupted or hand-broken sidecar must only skip that page, not abort loading the rest of
+    // the directory, same principle as commands/form/push.ts.
+    async loadFiles(dir) {
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const pages = [];
+        for (const file of files) {
+            if (extname(file) !== '.html')
+                continue;
+            const contentPath = join(dir, file);
+            const metaPath = join(dir, `${basename(file, '.html')}.json`);
+            let meta = {};
+            try {
+                const parsed = JSON.parse(await readFile(metaPath, 'utf8'));
+                if (typeof parsed !== 'object' || parsed === null) {
+                    this.warn(`Skipping "${metaPath}": not a JSON object`);
+                    continue;
+                }
+                meta = parsed;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    this.warn(`Skipping "${metaPath}": ${error.message}`);
+                    continue;
+                }
+            }
+            let content;
+            try {
+                content = await readFile(contentPath, 'utf8');
+            }
+            catch (error) {
+                this.warn(`Skipping "${contentPath}": ${error.message}`);
+                continue;
+            }
+            pages.push({ content, contentPath, meta, metaPath });
+        }
+        return pages;
+    }
+    // PUT-then-404-fallback-POST, same dance as commands/form/push.ts: pages are id-based.
+    //
+    // ponytail: `parent` round-trips as the source site's numeric page id untouched, so pushing
+    // to a site where that id belongs to a different page (or nothing) silently mis-parents or
+    // orphans the page. No id-remapping across sites here; fine for same-hierarchy environments,
+    // revisit if pushing across sites with divergent page trees becomes a real workflow.
+    async pushPage(page, task) {
+        const title = getPageTitle(page.meta);
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${title}`;
+            return;
+        }
+        try {
+            const id = getPageId(page.meta);
+            const payload = { ...page.meta, content: page.content };
+            if (id === null) {
+                const created = await this.wp.post(PAGE_ENDPOINT, payload);
+                const newId = getPageId(created);
+                if (newId !== null)
+                    await this.ensureCanonicalFilename(page, newId, title);
+            }
+            else {
+                try {
+                    await this.wp.put(`${PAGE_ENDPOINT}/${id}`, payload);
+                    await this.ensureCanonicalFilename(page, id, title);
+                }
+                catch (error) {
+                    // The id recorded locally doesn't exist on this site (e.g. a fresh install): create
+                    // it instead of failing, and adopt whatever id the site assigns.
+                    if (!isNotFoundError(error))
+                        throw error;
+                    const created = await this.wp.post(PAGE_ENDPOINT, payload);
+                    const newId = getPageId(created);
+                    if (newId !== null)
+                        await this.ensureCanonicalFilename(page, newId, title);
+                }
+            }
+            if (task)
+                task.output = `Pushed: ${title}`;
+        }
+        catch (error) {
+            this.reportTaskFailure(`Failed to push ${title}: ${error.message}`, error, task);
+        }
+    }
+}

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

@@ -3,9 +3,9 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<void>;
     private activatePlugin;
     private installPlugin;

package/dist/commands/plugin/push.js

@@ -7,8 +7,8 @@ export default class Push extends PushCommand {
     static examples = ['$ lps plugin push', '$ lps plugin push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
-    failedCount = 0;
     async run() {
         const { url } = this.siteConfig;
         const manifest = this.localConfig.plugins;
@@ -62,12 +62,6 @@ export default class Push extends PushCommand {
         }
         await this.recordSuccess();
     }
-    // `task` is only passed when called from within a running Listr task list (see `run()`); it lets
-    // status lines go through `task.output` instead of `this.log`/`this.warn`, which would otherwise
-    // race with the renderer repainting the terminal. Called without `task` (e.g. directly in tests),
-    // it falls back to plain logging. Rethrowing on failure (rather than swallowing) is what lets Listr
-    // mark the task as failed (red cross) instead of completed, even though `exitOnError: false` stops
-    // that failure from aborting sibling tasks in the same list.
     async activatePlugin(file, slug, task) {
         await this.performPluginAction('activate', slug, () => this.wp.put(`wp/v2/plugins/${file}`, { status: 'active' }), task);
     }
@@ -84,13 +78,7 @@ export default class Push extends PushCommand {
                 this.log(`  ${message}`);
         }
         catch (error) {
-            const message = `Failed to ${verb} ${slug}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to ${verb} ${slug}: ${error.message}`, error, task);
         }
     }
 }

package/dist/commands/project/config.d.ts

@@ -3,6 +3,7 @@ export default class Config extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private maybeBootstrapLoopressFull;
     private promptManualCredentials;
     private resolveCredentials;
     private resolveProject;