@loopress/cli 0.16.0 → 0.18.0

package/dist/commands/form/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/form/list.js

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

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

@@ -0,0 +1,14 @@
+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: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private findOrphanedFiles;
+}
+export declare function slug(title: string): string;

package/dist/commands/form/pull.js

@@ -0,0 +1,79 @@
+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 { LoopressCommand } from '../../lib/base.js';
+import { FORM_ENDPOINT, getFormId, getFormTitle } from '../../utils/form-format.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
+    };
+    static description = 'Pull forms from WordPress';
+    static examples = ['$ lps form pull'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+    };
+    async run() {
+        const { args } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolveFormPath(args.path);
+        this.log(`Pulling forms from ${url}`);
+        this.log(`Forms path: ${path}`);
+        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))));
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${withId.length} form${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((form) => {
+            const id = getFormId(form);
+            const title = getFormTitle(form);
+            return {
+                async task(_ctx, task) {
+                    await writeFile(join(path, `${id}-${slug(title)}.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(', ')}`);
+        }
+        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

@@ -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: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private failedCount;
+    run(): Promise<void>;
+    private ensureCanonicalFilename;
+    private loadFiles;
+    private pushForm;
+}

package/dist/commands/form/push.js

@@ -0,0 +1,130 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { readdir, readFile, rename } from 'node:fs/promises';
+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';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to forms directory (overrides project config)' }),
+    };
+    static description = 'Push forms to WordPress. Local files created or updated remotely are renamed on disk to the `<id>-<slug>.json` convention.';
+    static examples = ['$ lps form push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+    };
+    failedCount = 0;
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveFormPath(args.path);
+        this.log(`Pushing forms to ${url}`);
+        this.log(`Forms path: ${path}`);
+        const files = await this.loadFiles(path);
+        this.log(`Found ${files.length} form${files.length === 1 ? '' : 's'} to push`);
+        await new Listr(files.map(({ data, filePath }) => ({
+            task: async (_ctx, task) => this.pushForm(filePath, data, task),
+            title: `Push ${getFormTitle(data)}`,
+        })), { concurrent: false, exitOnError: false }).run();
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} form${this.failedCount === 1 ? '' : 's'} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All forms pushed.');
+    }
+    // Renames the local file to the `<id>-<slug>.json` convention used by `form pull`
+    // whenever it doesn't already match (a hand-created file with no id, or a stale slug after
+    // 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`);
+        if (filePath !== canonicalPath)
+            await rename(filePath, canonicalPath);
+    }
+    // One file is read in isolation: a corrupted or hand-broken JSON file must only skip that
+    // form, not abort loading the rest of the directory, same principle as loadObjects() in
+    // commands/acf/push.ts.
+    async loadFiles(dir) {
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        const forms = [];
+        for (const file of files) {
+            if (extname(file) !== '.json')
+                continue;
+            const filePath = join(dir, file);
+            let parsed;
+            try {
+                parsed = JSON.parse(await readFile(filePath, 'utf8'));
+            }
+            catch (error) {
+                this.warn(`Skipping "${filePath}": ${error.message}`);
+                continue;
+            }
+            if (typeof parsed !== 'object' || parsed === null) {
+                this.warn(`Skipping "${filePath}": not a JSON object`);
+                continue;
+            }
+            forms.push({ data: parsed, filePath });
+        }
+        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.
+    async pushForm(filePath, data, task) {
+        const title = getFormTitle(data);
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${title}`;
+            return;
+        }
+        try {
+            const id = getFormId(data);
+            if (id === null) {
+                const created = await this.wp.post(FORM_ENDPOINT, data);
+                const newId = getFormId(created);
+                if (newId !== null)
+                    await this.ensureCanonicalFilename(filePath, newId, title);
+            }
+            else {
+                try {
+                    await this.wp.put(`${FORM_ENDPOINT}/${id}`, data);
+                    await this.ensureCanonicalFilename(filePath, 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(FORM_ENDPOINT, data);
+                    const newId = getFormId(created);
+                    if (newId !== null)
+                        await this.ensureCanonicalFilename(filePath, newId, title);
+                }
+            }
+            if (task)
+                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;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+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>;
+        'post-type': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private fetchRedirects;
+}

package/dist/commands/seo/list.js

@@ -0,0 +1,60 @@
+import { Flags } from '@oclif/core';
+import { LoopressCommand } from '../../lib/base.js';
+import { DEFAULT_POST_TYPES, SEO_REDIRECTS_ENDPOINT, seoPostMetaEndpoint } from '../../utils/seo-format.js';
+export default class List extends LoopressCommand {
+    static description = 'List posts with SEO meta, and redirects if supported by the active SEO plugin, on WordPress';
+    static examples = ['$ lps seo list', '$ lps seo list --post-type post'];
+    static flags = {
+        json: Flags.boolean({ char: 'j', description: 'Output in JSON format' }),
+        'post-type': Flags.string({ description: 'Limit to specific post types', multiple: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(List);
+        const postTypes = flags['post-type'] && flags['post-type'].length > 0 ? flags['post-type'] : [...DEFAULT_POST_TYPES];
+        const byType = {};
+        for (const postType of postTypes) {
+            byType[postType] = await this.wp.get(seoPostMetaEndpoint(postType));
+        }
+        const { redirects, unsupportedReason } = await this.fetchRedirects();
+        if (flags.json) {
+            this.log(JSON.stringify({ postMeta: byType, redirects: redirects ?? undefined, redirectsUnsupported: unsupportedReason }, null, 2));
+            return;
+        }
+        for (const postType of postTypes) {
+            const posts = byType[postType];
+            this.log(`${postType} (${posts.length}):`);
+            if (posts.length === 0) {
+                this.log('  (none)');
+                this.log('');
+                continue;
+            }
+            for (const post of posts) {
+                this.log(`  ${post.slug}. ${post.title}`);
+            }
+            this.log('');
+        }
+        if (unsupportedReason) {
+            this.log(`redirects: ${unsupportedReason}`);
+            return;
+        }
+        this.log(`redirects (${redirects.length}):`);
+        if (redirects.length === 0) {
+            this.log('  (none)');
+            return;
+        }
+        for (const redirect of redirects) {
+            this.log(`  ${redirect.id}. [${redirect.status}] ${redirect.headerCode} -> ${redirect.urlTo}`);
+        }
+    }
+    // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast); reported
+    // as a line in the listing rather than failing the whole command, since post meta above may
+    // well have succeeded.
+    async fetchRedirects() {
+        try {
+            return { redirects: await this.wp.get(SEO_REDIRECTS_ENDPOINT), unsupportedReason: undefined };
+        }
+        catch (error) {
+            return { redirects: null, unsupportedReason: error.message };
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import { LoopressCommand } from '../../lib/base.js';
+import { SeoRedirect } from '../../utils/seo-format.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: {
+        'post-type': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private findOrphanedFiles;
+    private pullPostMeta;
+    private pullRedirects;
+    private pullSettings;
+}
+export declare function redirectFileBase(redirect: SeoRedirect): string;

package/dist/commands/seo/pull.js

@@ -0,0 +1,134 @@
+import { Args, Flags } 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 { LoopressCommand } from '../../lib/base.js';
+import { DEFAULT_POST_TYPES, SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, } from '../../utils/seo-format.js';
+export default class Pull extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
+    };
+    static description = 'Pull SEO settings, post meta, and (if supported) redirects from WordPress';
+    static examples = ['$ lps seo pull', '$ lps seo pull --post-type post --post-type page'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+        'post-type': Flags.string({ description: 'Limit post meta to specific post types', multiple: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Pull);
+        const { url } = this.siteConfig;
+        const path = this.resolveSeoPath(args.path);
+        const postTypes = flags['post-type'] && flags['post-type'].length > 0 ? flags['post-type'] : [...DEFAULT_POST_TYPES];
+        this.log(`Pulling SEO configuration from ${url}`);
+        this.log(`SEO path: ${path}`);
+        await this.pullSettings(path);
+        for (const postType of postTypes) {
+            await this.pullPostMeta(postType, path);
+        }
+        await this.pullRedirects(path);
+    }
+    // Shared by post-meta (`<slug>.json`) and redirects (`<id>-<slug>.json`) directories: a local
+    // file whose identity is no longer in the current remote list belongs to something deleted on
+    // WordPress. Left on disk, it would silently come back to life on the next `seo push`.
+    async findOrphanedFiles(dir, keepKeys, numericIdPrefix) {
+        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;
+            if (numericIdPrefix) {
+                const match = /^(\d+)-/.exec(file);
+                return match !== null && !keepKeys.has(match[1]);
+            }
+            return !keepKeys.has(file.slice(0, -'.json'.length));
+        });
+    }
+    async pullPostMeta(postType, basePath) {
+        const dir = join(basePath, 'post-meta', postType);
+        const remote = await this.wp.get(seoPostMetaEndpoint(postType));
+        const orphans = await this.findOrphanedFiles(dir, new Set(remote.map((post) => post.slug)), false);
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${remote.length} ${postType} post-meta file(s) to ${dir}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        if (remote.length > 0)
+            await mkdir(dir, { recursive: true });
+        await new Listr(remote.map((post) => ({
+            async task(_ctx, task) {
+                await writeFile(join(dir, `${post.slug}.json`), JSON.stringify(post, null, 2) + '\n');
+                task.output = `Pulled: ${post.slug}`;
+            },
+            title: `Pull ${post.slug}`,
+        }))).run();
+        for (const file of orphans)
+            await rm(join(dir, file), { force: true });
+        if (orphans.length > 0) {
+            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
+        }
+        this.log(`Pulled ${remote.length} ${postType} post-meta file(s) to ${dir}`);
+    }
+    // Redirects are only supported by some SeoProvider backends (RankMath, not Yoast). Unlike
+    // push (which must fail loudly if the user has local redirect files that can't be synced),
+    // pull degrades gracefully here: the active plugin never supporting redirects isn't an error
+    // in the same sense a deleted-on-WordPress file is, there's simply nothing to pull.
+    async pullRedirects(basePath) {
+        const dir = join(basePath, 'redirects');
+        let remote;
+        try {
+            remote = await this.wp.get(SEO_REDIRECTS_ENDPOINT);
+        }
+        catch (error) {
+            this.warn(`Skipping redirects: ${error.message}`);
+            return;
+        }
+        const orphans = await this.findOrphanedFiles(dir, new Set(remote.map((redirect) => String(redirect.id))), true);
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${remote.length} redirect(s) to ${dir}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        if (remote.length > 0)
+            await mkdir(dir, { recursive: true });
+        await new Listr(remote.map((redirect) => ({
+            async task(_ctx, task) {
+                await writeFile(join(dir, `${redirectFileBase(redirect)}.json`), JSON.stringify(redirect, null, 2) + '\n');
+                task.output = `Pulled: redirect #${redirect.id}`;
+            },
+            title: `Pull redirect #${redirect.id}`,
+        }))).run();
+        for (const file of orphans)
+            await rm(join(dir, file), { force: true });
+        if (orphans.length > 0) {
+            this.warn(`Removed ${orphans.length} local file${orphans.length === 1 ? '' : 's'} in ${dir} no longer present on WordPress: ${orphans.join(', ')}`);
+        }
+        this.log(`Pulled ${remote.length} redirect(s) to ${dir}`);
+    }
+    async pullSettings(basePath) {
+        const file = join(basePath, 'settings.json');
+        const settings = await this.wp.get(SEO_SETTINGS_ENDPOINT);
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull settings to ${file}`);
+            return;
+        }
+        await mkdir(basePath, { recursive: true });
+        await writeFile(file, JSON.stringify(settings, null, 2) + '\n');
+        this.log(`Pulled settings to ${file}`);
+    }
+}
+export function redirectFileBase(redirect) {
+    const slug = slugify(redirect.urlTo || 'redirect', { lower: true, strict: true });
+    return `${redirect.id}-${slug || 'redirect'}`;
+}

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

@@ -0,0 +1,20 @@
+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: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private failedCount;
+    run(): Promise<void>;
+    private jsonFilesIn;
+    private pushPostMeta;
+    private pushPostMetaFile;
+    private pushRedirectFile;
+    private pushRedirects;
+    private pushSettings;
+    private renameToCanonical;
+}