@loopress/cli 0.18.0 → 0.19.0

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

@@ -7,9 +7,9 @@ export default class Pull extends LoopressCommand {
     static examples: string[];
     static flags: {
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private findOrphanedFiles;
     private pullType;
 }

package/dist/commands/acf/pull.js

@@ -1,8 +1,9 @@
 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 { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class Pull extends LoopressCommand {
     static args = {
@@ -12,6 +13,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps acf pull', '$ lps acf pull --type field-groups'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
     async run() {
@@ -25,28 +27,18 @@ export default class Pull extends LoopressCommand {
             await this.pullType(type, path);
         }
     }
-    // Every file in a type's subdirectory is unambiguously `<key>.json` — unlike snippets, ACF
-    // objects have no numeric-id/slug filename convention. `key` is the stable identity ACF
-    // itself already uses for this (see its own Local JSON mechanism), so orphan detection is a
-    // plain set difference, no regex/extension juggling needed.
-    async findOrphanedFiles(dir, keepKeys) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        return files.filter((file) => extname(file) === '.json' && !keepKeys.has(file.slice(0, -'.json'.length)));
-    }
     async pullType(type, basePath) {
         const dir = join(basePath, type);
         const remoteList = await this.wp.get(acfEndpoint(type));
         const withKey = remoteList.filter((object) => getAcfKey(object) !== null);
         const skipped = remoteList.length - withKey.length;
-        const orphans = await this.findOrphanedFiles(dir, new Set(withKey.map((object) => getAcfKey(object))));
+        // Every file in a type's subdirectory is unambiguously `<key>.json`: `key` is the stable
+        // identity ACF itself already uses (see its own Local JSON mechanism), no numeric-id/slug
+        // filename convention like snippets.
+        const orphans = await findOrphanedFiles(dir, new Set(withKey.map((object) => getAcfKey(object))), {
+            extensions: ['.json'],
+            key: basenameKey,
+        });
         if (this.dryRun) {
             this.log(`[dry-run] Would pull ${withKey.length} ${type} to ${dir}`);
             if (orphans.length > 0) {
@@ -66,12 +58,7 @@ export default class Pull extends LoopressCommand {
                 title: `Pull ${key}`,
             };
         })).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(', ')}`);
-        }
+        await this.removeOrphanedFiles(dir, orphans, `in ${dir} no longer present on WordPress`);
         this.log(`Pulled ${withKey.length} ${type} to ${dir}`);
         if (skipped > 0) {
             this.warn(`${skipped} ${type} skipped because they have no key`);

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

@@ -7,9 +7,9 @@ export default class Push extends PushCommand {
     static examples: string[];
     static flags: {
         type: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<void>;
     private loadObjects;
     private pushObject;

package/dist/commands/acf/push.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+import { join } from 'node:path';
+import { loadFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { ACF_OBJECT_TYPES, acfEndpoint, getAcfKey } from '../../utils/acf-format.js';
 export default class Push extends PushCommand {
@@ -12,9 +12,9 @@ export default class Push extends PushCommand {
     static examples = ['$ lps acf push', '$ lps acf push --type field-groups'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
         type: Flags.string({ description: 'Limit to specific ACF object types', multiple: true, options: ACF_OBJECT_TYPES }),
     };
-    failedCount = 0;
     async run() {
         const { args, flags } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -33,45 +33,22 @@ export default class Push extends PushCommand {
         await this.recordSuccess();
         this.log('All ACF objects pushed.');
     }
-    // One object's file is read in isolation: a corrupted or hand-broken JSON file (or one
-    // missing/emptying its "key") must only skip that object, not abort loading the rest of
-    // the type's directory — same principle as loadSnippets() for the snippet feature.
     async loadObjects(dir) {
-        let files;
-        try {
-            files = await readdir(dir);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        const objects = [];
-        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 || getAcfKey(parsed) === null) {
-                this.warn(`Skipping "${filePath}": missing or invalid "key"`);
-                continue;
-            }
-            objects.push(parsed);
-        }
-        return objects;
+        return loadFiles(dir, {
+            extension: '.json',
+            onSkip: (message) => this.warn(message),
+            parse(raw) {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed !== 'object' || parsed === null || getAcfKey(parsed) === null) {
+                    throw new Error('missing or invalid "key"');
+                }
+                return parsed;
+            },
+        });
     }
-    // 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 objects push regardless. POST alone covers create-or-update (the controller resolves
-    // that server-side via the object's `key`), unlike snippet push there's no numeric-id PUT/404
-    // fallback dance, and no rename-on-push step since `key` is permanently stable.
+    // POST alone covers create-or-update (the controller resolves that server-side via the
+    // object's `key`), unlike snippet push there's no numeric-id PUT/404 fallback dance, and no
+    // rename-on-push step since `key` is permanently stable.
     async pushObject(type, object, task) {
         const key = getAcfKey(object) ?? '(unknown)';
         if (this.dryRun) {
@@ -85,13 +62,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${key}`;
         }
         catch (error) {
-            const message = `Failed to push ${key}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${key}: ${error.message}`, error, task);
         }
     }
     async pushType(type, basePath) {

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

@@ -6,8 +6,8 @@ export default class Pull extends LoopressCommand {
     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 findOrphanedFiles;
 }

package/dist/commands/api/pull.js

@@ -1,8 +1,9 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { mkdir, readdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { basenameKey, findOrphanedFiles } from '../../lib/find-orphaned-files.js';
 export default class Pull extends LoopressCommand {
     static args = {
         path: Args.string({ description: 'Path to api directory (overrides project config)' }),
@@ -11,6 +12,7 @@ export default class Pull extends LoopressCommand {
     static examples = ['$ lps api pull', '$ lps api pull --path ./api'];
     static flags = {
         ...LoopressCommand.dryRunFlag,
+        ...LoopressCommand.yesFlag,
     };
     async run() {
         const { args } = await this.parse(Pull);
@@ -19,11 +21,13 @@ export default class Pull extends LoopressCommand {
         this.log(`Pulling API routes from ${url}`);
         this.log(`API path: ${path}`);
         const files = await this.wp.get('loopress/v1/api-files');
-        // Files following the `<filename>.php` convention no longer present remotely belong to
-        // a route deleted on WordPress. Left on disk, they'd silently come back to life the next
-        // time `api push` runs (see obsidian/Product/Push Deletion Rules.md: push itself stays
-        // additive-only, but pull already cleans up locally, same as `snippet pull`).
-        const orphans = await this.findOrphanedFiles(path, new Set(files.map((file) => file.filename)));
+        // A `<filename>.php` no longer present remotely belongs to a route deleted on WordPress
+        // (push itself stays additive-only, but pull already cleans up locally, same as
+        // `snippet pull`).
+        const orphans = await findOrphanedFiles(path, new Set(files.map((file) => file.filename)), {
+            extensions: ['.php'],
+            key: basenameKey,
+        });
         if (this.dryRun) {
             this.log(`[dry-run] Would pull ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
             if (orphans.length > 0) {
@@ -39,26 +43,7 @@ export default class Pull extends LoopressCommand {
             },
             title: `Pull ${file.filename}`,
         }))).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'} whose route no longer exists on WordPress: ${orphans.join(', ')}`);
-        }
+        await this.removeOrphanedFiles(path, orphans, 'whose route no longer exists on WordPress');
         this.log(`Pulled ${files.length} route file${files.length === 1 ? '' : 's'} to ${path}`);
     }
-    // Only ever matches `.php` files already following the flat `<filename>.php` convention
-    // that `api pull`/`push` themselves produce, so a hand-created non-.php file is never at
-    // risk of being picked up here.
-    async findOrphanedFiles(path, keepFilenames) {
-        let entries;
-        try {
-            entries = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        return entries.filter((entry) => entry.endsWith('.php') && !keepFilenames.has(entry.slice(0, -4)));
-    }
 }

package/dist/commands/api/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 loadFiles;
     private pushFile;

package/dist/commands/api/push.js

@@ -1,8 +1,16 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+import { basename } from 'node:path';
+import { loadFiles as loadDirectoryFiles } from '../../lib/load-files.js';
 import { PushCommand } from '../../lib/push-command.js';
+// Mirrors the server's own allowlist (wordpress-plugin ApiFilesController::FILENAME_PATTERN):
+// the filename becomes a URL path segment matched against this exact regex by the WP REST
+// route itself. A filename that doesn't match never reaches the controller, WordPress's
+// router returns a generic 404 before validate_callback runs, which the CLI's shared error
+// formatter reports as "is the plugin installed?", a confusing message for what is actually
+// an invalid filename. Checking client-side first turns that into an accurate error and
+// skips a network round-trip that could only ever fail.
+const FILENAME_PATTERN = /^[a-z0-9-]+$/;
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to api directory (overrides project config)' }),
@@ -11,8 +19,8 @@ export default class Push extends PushCommand {
     static examples = ['$ lps api push', '$ lps api push --path ./api'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
-    failedCount = 0;
     async run() {
         const { args } = await this.parse(Push);
         const { url } = this.siteConfig;
@@ -34,25 +42,17 @@ export default class Push extends PushCommand {
         this.log('All API routes pushed.');
     }
     async loadFiles(path) {
-        let entries;
-        try {
-            entries = await readdir(path);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return [];
-            throw error;
-        }
-        const files = [];
-        for (const entry of entries) {
-            if (extname(entry) !== '.php')
-                continue;
-            const content = await readFile(join(path, entry), 'utf8');
-            files.push({ content, filename: entry.slice(0, -4) });
-        }
-        return files;
+        return loadDirectoryFiles(path, {
+            extension: '.php',
+            onSkip: (message) => this.warn(message),
+            parse: (raw, filePath) => ({ content: raw, filename: basename(filePath, '.php') }),
+        });
     }
     async pushFile(file, task) {
+        if (!FILENAME_PATTERN.test(file.filename)) {
+            const message = `Invalid filename "${file.filename}": only lowercase letters, digits, and hyphens are allowed (e.g. "hello-world.php")`;
+            this.reportTaskFailure(message, new Error(message), task);
+        }
         if (this.dryRun) {
             if (task)
                 task.output = `[dry-run] Would push: ${file.filename}`;
@@ -64,13 +64,7 @@ export default class Push extends PushCommand {
                 task.output = `Pushed: ${file.filename}`;
         }
         catch (error) {
-            const message = `Failed to push ${file.filename}: ${error.message}`;
-            if (task)
-                task.output = message;
-            else
-                this.warn(`  ${message}`);
-            this.failedCount++;
-            throw error;
+            this.reportTaskFailure(`Failed to push ${file.filename}: ${error.message}`, error, task);
         }
     }
 }

package/dist/commands/composer/init.js

@@ -3,11 +3,12 @@ import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { LoopressCommand } from '../../lib/base.js';
+import { isInteractive } from '../../lib/interactive.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
+// LoopressEnvironment::getLoopressDir), 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'],
@@ -22,6 +23,10 @@ export default class ComposerInit extends LoopressCommand {
     async run() {
         const composerJsonPath = join(process.cwd(), this.rootDir, 'composer.json');
         if (existsSync(composerJsonPath)) {
+            if (!isInteractive()) {
+                this.log('composer.json already exists, not overwriting (non-interactive terminal).');
+                return;
+            }
             const overwrite = await confirm({ default: false, message: 'composer.json already exists. Overwrite?' });
             if (!overwrite) {
                 this.log('Aborted.');
@@ -29,6 +34,11 @@ export default class ComposerInit extends LoopressCommand {
             }
         }
         const composerJson = {
+            // composer/installers is itself a Composer plugin, and Composer 2.2+ refuses to run any
+            // plugin that isn't explicitly trusted when running non-interactively (which every
+            // `composer push` on the server does). Without this, the very first real push against
+            // this scaffold 500s on Composer's own plugin-trust gate before ever touching a package.
+            config: { 'allow-plugins': { [INSTALLERS_PACKAGE]: true } },
             extra: { 'installer-paths': INSTALLER_PATHS },
             name: 'loopress/site-dependencies',
             repositories: [WPACKAGIST_REPOSITORY],

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

@@ -3,6 +3,7 @@ export default class ComposerPush 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>;
     };
     run(): Promise<void>;

package/dist/commands/composer/push.js

@@ -2,11 +2,15 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { PushCommand } from '../../lib/push-command.js';
+import { isTimeoutError } from '../../lib/wp-client.js';
+// A cold composer install easily exceeds the global 30s timeout of WpClient.
+const COMPOSER_SYNC_TIMEOUT_MS = 600_000;
 export default class ComposerPush extends PushCommand {
     static description = 'Push composer.json and composer.lock to WordPress and run composer install';
     static examples = ['$ lps composer push', '$ lps composer push --dry-run'];
     static flags = {
         ...PushCommand.dryRunFlag,
+        ...PushCommand.yesFlag,
     };
     async run() {
         const { url } = this.siteConfig;
@@ -29,10 +33,19 @@ export default class ComposerPush extends PushCommand {
         }
         if (this.dryRun)
             return;
-        await this.wp.post('loopress/v1/composer/sync', {
-            composerJson: composerJsonRaw,
-            composerLock: composerLockRaw,
-        });
+        this.log('Running composer install on the server, this can take a few minutes...');
+        try {
+            await this.wp.post('loopress/v1/composer/sync', {
+                composerJson: composerJsonRaw,
+                composerLock: composerLockRaw,
+            }, { timeoutMs: COMPOSER_SYNC_TIMEOUT_MS });
+        }
+        catch (error) {
+            if (isTimeoutError(error)) {
+                this.error(`${error.message} The composer install may still be running on the server.`);
+            }
+            throw error;
+        }
         this.log('composer install completed on the server.');
         await this.recordSuccess();
     }

package/dist/commands/doctor.d.ts

@@ -0,0 +1,8 @@
+import { LoopressCommand } from '../lib/base.js';
+export default class Doctor extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private check;
+    private reportPluginVersion;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,79 @@
+import { configManager } from '../config/project-config.manager.js';
+import { LoopressCommand } from '../lib/base.js';
+import { isNotFoundError } from '../lib/wp-client.js';
+import { diagnoseWpSite } from '../lib/wp-site-diagnostic.js';
+export default class Doctor extends LoopressCommand {
+    static description = 'Diagnose connectivity, plugin and credential problems for the targeted environment';
+    static examples = ['$ lps doctor', '$ lps doctor --env production'];
+    async run() {
+        const { name, token, url } = this.siteConfig;
+        const project = this.localConfig.projectId
+            ? configManager.getProject(this.localConfig.projectId)
+            : configManager.getCurrentProject();
+        this.log(`Project:      ${project?.name ?? '(unknown)'}`);
+        this.log(`Environment:  ${name}`);
+        this.log(`URL:          ${url}`);
+        this.log('');
+        let failed = 0;
+        const reachable = await this.check('WordPress REST API reachable', async () => {
+            const diagnostic = await diagnoseWpSite(url);
+            if (!diagnostic.ok)
+                throw new Error(diagnostic.reason);
+        });
+        if (!reachable) {
+            failed++;
+            this.log('- Remaining checks skipped while the site is unreachable.');
+            this.error('1 check failed.', { exit: 1 });
+        }
+        if (!token) {
+            this.log('✗ Credentials configured');
+            this.log(`  No credentials stored for ${url}. Run \`lps project config\` to add them.`);
+            this.log('- Remaining checks skipped without credentials.');
+            this.error('1 check failed.', { exit: 1 });
+        }
+        // The namespace index answers regardless of which Loopress features are active, so a 404
+        // here can only mean the plugin itself is missing or outdated (WpClient's 404 message
+        // already says exactly that).
+        if (!(await this.check('Loopress plugin installed (loopress/v1 endpoints)', () => this.wp.get('loopress/v1')))) {
+            failed++;
+        }
+        // wp/v2/users/me is WordPress core and requires authentication, so it validates the
+        // application password without depending on any Loopress feature.
+        if (!(await this.check('Credentials accepted (authenticated request)', () => this.wp.get('wp/v2/users/me')))) {
+            failed++;
+        }
+        await this.reportPluginVersion();
+        this.log('');
+        if (failed > 0) {
+            this.error(`${failed} check${failed === 1 ? '' : 's'} failed.`, { exit: 1 });
+        }
+        this.log('All checks passed.');
+    }
+    async check(title, run) {
+        try {
+            await run();
+            this.log(`✓ ${title}`);
+            return true;
+        }
+        catch (error) {
+            this.log(`✗ ${title}`);
+            this.log(`  ${error.message}`);
+            return false;
+        }
+    }
+    // Informational only: Loopress Light does not expose loopress/v1/update, and an old plugin
+    // predates it, neither should flip the doctor to a failure when everything else works.
+    async reportPluginVersion() {
+        try {
+            const status = await this.wp.get('loopress/v1/update');
+            this.log(`✓ Plugin version: ${status.current_version ?? '(unknown)'}`);
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                this.log('- Plugin version: not exposed by this plugin edition.');
+                return;
+            }
+            this.log(`- Plugin version: could not be read. ${error.message}`);
+        }
+    }
+}

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

@@ -6,9 +6,8 @@ export default class Pull extends LoopressCommand {
     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 findOrphanedFiles;
 }
-export declare function slug(title: string): string;

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;