@loopress/cli 0.15.0 → 0.17.0

package/dist/commands/composer/init.js

@@ -0,0 +1,47 @@
+import { confirm } from '@inquirer/prompts';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { LoopressCommand } from '../../lib/base.js';
+const WPACKAGIST_REPOSITORY = { type: 'composer', url: 'https://wpackagist.org' };
+const INSTALLERS_PACKAGE = 'composer/installers';
+const INSTALLERS_CONSTRAINT = '^2.0';
+// The server runs Composer with `--working-dir` set to wp-content/loopress/ (see
+// LoopressEnvironment::getDxDir), not the WordPress root, so installer-paths must climb out
+// of that directory to land plugins/themes in their usual wp-content/ locations.
+const INSTALLER_PATHS = {
+    '../plugins/{$name}/': ['type:wordpress-plugin'],
+    '../themes/{$name}/': ['type:wordpress-theme'],
+};
+export default class ComposerInit extends LoopressCommand {
+    static description = 'Create a composer.json wired to WPackagist for installing WordPress.org plugins and themes';
+    static examples = ['$ lps composer init', '$ lps composer init --dry-run'];
+    static flags = {
+        ...LoopressCommand.dryRunFlag,
+    };
+    async run() {
+        const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
+        if (existsSync(composerJsonPath)) {
+            const overwrite = await confirm({ default: false, message: 'composer.json already exists. Overwrite?' });
+            if (!overwrite) {
+                this.log('Aborted.');
+                return;
+            }
+        }
+        const composerJson = {
+            extra: { 'installer-paths': INSTALLER_PATHS },
+            name: 'loopress/site-dependencies',
+            repositories: [WPACKAGIST_REPOSITORY],
+            require: {
+                [INSTALLERS_PACKAGE]: INSTALLERS_CONSTRAINT,
+            },
+        };
+        if (this.dryRun) {
+            this.log(`[dry-run] Would write composer.json to ${composerJsonPath}`);
+            return;
+        }
+        await writeFile(composerJsonPath, JSON.stringify(composerJson, null, 2) + '\n', 'utf8');
+        this.log(`Wrote composer.json to ${composerJsonPath}`);
+        this.log('Add plugins with `wpackagist-plugin/<slug>` and a theme with `wpackagist-theme/<slug>` in require, then run `lps composer push`.');
+    }
+}

package/dist/commands/composer/pull.js

@@ -2,21 +2,24 @@ import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
 export default class ComposerPull extends LoopressCommand {
-    static description = 'Pull composer.lock from WordPress';
+    static description = 'Pull composer.json and composer.lock from WordPress';
     static examples = ['$ lps composer pull', '$ lps composer pull --dry-run'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
     };
     async run() {
         const { url } = this.siteConfig;
-        this.log(`Pulling composer.lock from ${url}`);
+        this.log(`Pulling composer.json and composer.lock from ${url}`);
+        const { composerJson } = await this.wp.get('loopress/v1/composer/json');
         const { composerLock } = await this.wp.get('loopress/v1/composer/lock');
         if (this.dryRun) {
-            this.log('[dry-run] Would write composer.lock');
+            this.log('[dry-run] Would write composer.json and composer.lock');
             return;
         }
+        const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         const lockPath = join(process.cwd(), this.rootDir, 'composer.lock');
+        await writeFile(composerJsonPath, composerJson, 'utf8');
         await writeFile(lockPath, composerLock, 'utf8');
-        this.log(`Wrote composer.lock`);
+        this.log(`Wrote composer.json and composer.lock`);
     }
 }

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;
+}

package/dist/commands/seo/push.js

@@ -0,0 +1,171 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { readdir, readFile, rm, writeFile } 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 { SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, seoRedirectEndpoint, } from '../../utils/seo-format.js';
+import { redirectFileBase } from './pull.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
+    };
+    static description = 'Push SEO settings, post meta, and redirects to WordPress. Local redirect files created remotely are renamed on disk to the `<id>-<slug>` convention. Fails clearly per file if the active SEO plugin does not support redirects.';
+    static examples = ['$ lps seo push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+    };
+    failedCount = 0;
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveSeoPath(args.path);
+        this.log(`Pushing SEO configuration to ${url}`);
+        this.log(`SEO path: ${path}`);
+        await this.pushSettings(path);
+        await this.pushPostMeta(path);
+        await this.pushRedirects(path);
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} SEO item${this.failedCount === 1 ? '' : 's'} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All SEO configuration pushed.');
+    }
+    async jsonFilesIn(dir) {
+        try {
+            return (await readdir(dir)).filter((file) => extname(file) === '.json');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    async pushPostMeta(basePath) {
+        const root = join(basePath, 'post-meta');
+        let postTypeDirs;
+        try {
+            postTypeDirs = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const postType of postTypeDirs) {
+            const dir = join(root, postType);
+            const files = await this.jsonFilesIn(dir);
+            if (files.length === 0)
+                continue;
+            this.log(`Found ${files.length} ${postType} post-meta file${files.length === 1 ? '' : 's'} to push`);
+            await new Listr(files.map((file) => ({
+                task: async (_ctx, task) => this.pushPostMetaFile(postType, join(dir, file), task),
+                title: `Push ${file}`,
+            })), { concurrent: false, exitOnError: false }).run();
+        }
+    }
+    async pushPostMetaFile(postType, filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const post = JSON.parse(await readFile(filePath, 'utf8'));
+            await this.wp.post(seoPostMetaEndpoint(postType), { meta: post.meta, slug: post.slug });
+            if (task)
+                task.output = `Pushed: ${post.slug}`;
+        }
+        catch (error) {
+            const message = `Failed to push ${filePath}: ${error.message}`;
+            if (task)
+                task.output = message;
+            else
+                this.warn(`  ${message}`);
+            this.failedCount++;
+            throw error;
+        }
+    }
+    async pushRedirectFile(filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const redirect = JSON.parse(await readFile(filePath, 'utf8'));
+            const payload = { headerCode: redirect.headerCode, sources: redirect.sources, status: redirect.status, urlTo: redirect.urlTo };
+            if (redirect.id) {
+                try {
+                    await this.wp.put(seoRedirectEndpoint(redirect.id), payload);
+                    if (task)
+                        task.output = `Pushed: redirect #${redirect.id}`;
+                    return;
+                }
+                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 (same fallback as snippet push).
+                    if (!isNotFoundError(error))
+                        throw error;
+                }
+            }
+            const created = await this.wp.post(SEO_REDIRECTS_ENDPOINT, payload);
+            await this.renameToCanonical(filePath, created);
+            if (task)
+                task.output = `Pushed: redirect #${created.id}`;
+        }
+        catch (error) {
+            const message = `Failed to push ${filePath}: ${error.message}`;
+            if (task)
+                task.output = message;
+            else
+                this.warn(`  ${message}`);
+            this.failedCount++;
+            throw error;
+        }
+    }
+    async pushRedirects(basePath) {
+        const dir = join(basePath, 'redirects');
+        const files = await this.jsonFilesIn(dir);
+        if (files.length === 0)
+            return;
+        this.log(`Found ${files.length} redirect${files.length === 1 ? '' : 's'} to push`);
+        await new Listr(files.map((file) => ({
+            task: async (_ctx, task) => this.pushRedirectFile(join(dir, file), task),
+            title: `Push ${file}`,
+        })), { concurrent: false, exitOnError: false }).run();
+    }
+    async pushSettings(basePath) {
+        const file = join(basePath, 'settings.json');
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${file}`);
+            return;
+        }
+        try {
+            await this.wp.put(SEO_SETTINGS_ENDPOINT, JSON.parse(raw));
+            this.log(`Pushed: ${file}`);
+        }
+        catch (error) {
+            this.failedCount++;
+            this.warn(`Failed to push ${file}: ${error.message}`);
+        }
+    }
+    async renameToCanonical(filePath, redirect) {
+        const dir = dirname(filePath);
+        const canonicalPath = join(dir, `${redirectFileBase(redirect)}.json`);
+        await writeFile(canonicalPath, JSON.stringify(redirect, null, 2) + '\n');
+        if (canonicalPath !== filePath)
+            await rm(filePath, { force: true });
+    }
+}

package/dist/help.js

@@ -7,7 +7,7 @@ const BANNER = `
    @@@@          ++++     ▗▖    ▗▄▖  ▗▄▖ ▗▄▄▖ ▗▄▄▖ ▗▄▄▄▖ ▗▄▄▖ ▗▄▄▖
   @@@@            ++++    ▐▌   ▐▌ ▐▌▐▌ ▐▌▐▌ ▐▌▐▌ ▐▌▐▌   ▐▌   ▐▌   
  @@@@              ++++   ▐▌   ▐▌ ▐▌▐▌ ▐▌▐▛▀▘ ▐▛▀▚▖▐▛▀▀▘ ▝▀▚▖ ▝▀▚▖
-  @@@@            ++++    ▐▙▄▄▖▝▚▄▞▘▝▚▄▞▘▐▌   ▐▌ ▐▌▐▙▄▄▖▗▄▄▞▘▗▄▄▞▘  (BETA)
+  @@@@            ++++    ▐▙▄▄▖▝▚▄▞▘▝▚▄▞▘▐▌   ▐▌ ▐▌▐▙▄▄▖▗▄▄▞▘▗▄▄▞▘  (ALPHA)
    @@@@          ++++   
     @@@@        ++++    
      @@@@@@@@@@@*++     

package/dist/lib/base.d.ts

@@ -13,6 +13,8 @@ export declare abstract class LoopressCommand extends Command {
     protected get rootDir(): string;
     protected get wp(): WpClient;
     init(): Promise<void>;
+    protected resolveAcfPath(override?: string): string;
+    protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -35,6 +35,16 @@ export class LoopressCommand extends Command {
         this.localConfig = await readLocalConfig();
         this.siteConfig = this.resolveEnvironment();
     }
+    resolveAcfPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.acfDir ?? 'acf');
+    }
+    resolveSeoPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.seoDir ?? 'seo');
+    }
     resolveSnippetsPath(override) {
         if (override)
             return override;

package/dist/types/project-config.generated.d.ts

@@ -11,6 +11,14 @@ export interface LoopressProjectConfiguration {
      * Directory where code snippets are read from and written to, relative to rootDir.
      */
     snippetsDir?: string;
+    /**
+     * Directory where ACF field groups, post types, taxonomies and options pages are read from and written to, relative to rootDir.
+     */
+    acfDir?: string;
+    /**
+     * Directory where SEO settings, post meta, and redirects (RankMath and Yoast SEO, whichever is active) are read from and written to, relative to rootDir.
+     */
+    seoDir?: string;
     /**
      * Project identifier from the global Loopress config. When set, takes precedence over the currently active project in the global config.
      */

package/dist/utils/acf-format.d.ts

@@ -0,0 +1,4 @@
+export declare const ACF_OBJECT_TYPES: readonly ["field-groups", "post-types", "taxonomies", "options-pages"];
+export type AcfObjectType = (typeof ACF_OBJECT_TYPES)[number];
+export declare function acfEndpoint(type: AcfObjectType): string;
+export declare function getAcfKey(data: Record<string, unknown>): null | string;

package/dist/utils/acf-format.js

@@ -0,0 +1,12 @@
+export const ACF_OBJECT_TYPES = ['field-groups', 'post-types', 'taxonomies', 'options-pages'];
+export function acfEndpoint(type) {
+    return `loopress/v1/acf/${type}`;
+}
+// Deliberately loose: ACF's own export JSON is large, deeply nested, and versioned by ACF
+// itself (new settings appear across ACF releases). We only need `key` for filenames/identity;
+// everything else round-trips through pull/push untouched, so there's no generated type for it
+// (see the plan for why: shadowing ACF's own schema would be an ongoing losing battle, and the
+// shared schema:types compiler options (additionalProperties: false) would be actively wrong here).
+export function getAcfKey(data) {
+    return typeof data.key === 'string' && data.key.trim() !== '' ? data.key : null;
+}

package/dist/utils/composer.d.ts

@@ -1,4 +1,12 @@
 export interface ComposerJson {
+    extra?: {
+        'installer-paths'?: Record<string, string[]>;
+    };
+    name?: string;
+    repositories?: Array<{
+        type: string;
+        url: string;
+    }>;
     require?: Record<string, string>;
     'require-dev'?: Record<string, string>;
 }

package/dist/utils/plugins.js

@@ -1,7 +1,9 @@
 // Loopress must never manage itself: pulling it into loopress.json would make a later
 // `plugin push` try to reinstall it from WordPress.org, where it doesn't exist, potentially
-// clobbering the plugin's own directory in the process.
-const LOOPRESS_PLUGIN_SLUG = 'loopress';
+// clobbering the plugin's own directory in the process. Checked against every slug this
+// plugin has ever shipped under (pre-rename "loopress", and the current "loopress-full" /
+// "loopress-light" editions), since a given site could be running any of them.
+const LOOPRESS_PLUGIN_SLUGS = new Set(['loopress', 'loopress-full', 'loopress-light']);
 export function mergePluginManifest(existing, incoming) {
     const merged = { ...existing, ...incoming };
     const added = Object.keys(incoming).filter((s) => !(s in existing));
@@ -25,7 +27,7 @@ export function parseInstalledPlugins(raw) {
         slug: slugFromPluginFile(item.plugin),
         version: item.version,
     }))
-        .filter((plugin) => plugin.slug !== LOOPRESS_PLUGIN_SLUG);
+        .filter((plugin) => !LOOPRESS_PLUGIN_SLUGS.has(plugin.slug));
 }
 export function diffPlugins(manifest, installed) {
     const installedMap = new Map(installed.map((p) => [p.slug, p]));

package/dist/utils/seo-format.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_POST_TYPES: readonly ["post", "page"];
+export declare const SEO_SETTINGS_ENDPOINT = "loopress/v1/seo/settings";
+export declare const SEO_REDIRECTS_ENDPOINT = "loopress/v1/seo/redirects";
+export declare function seoRedirectEndpoint(id: number): string;
+export declare function seoPostMetaEndpoint(postType: string): string;
+export interface SeoPostMeta {
+    meta: Record<string, unknown>;
+    slug: string;
+    title: string;
+}
+export interface SeoRedirect {
+    createdAt: null | string;
+    headerCode: number;
+    hits: number;
+    id: number;
+    sources: unknown;
+    status: string;
+    updatedAt: null | string;
+    urlTo: string;
+}

package/dist/utils/seo-format.js

@@ -0,0 +1,10 @@
+// Post types synced by `lps seo pull` when --post-type isn't given.
+export const DEFAULT_POST_TYPES = ['post', 'page'];
+export const SEO_SETTINGS_ENDPOINT = 'loopress/v1/seo/settings';
+export const SEO_REDIRECTS_ENDPOINT = 'loopress/v1/seo/redirects';
+export function seoRedirectEndpoint(id) {
+    return `${SEO_REDIRECTS_ENDPOINT}/${id}`;
+}
+export function seoPostMetaEndpoint(postType) {
+    return `loopress/v1/seo/post-meta/${postType}`;
+}