@loopress/cli 0.29.0 → 0.31.0

package/dist/commands/plugin/audit.js

@@ -1,5 +1,6 @@
 import got from 'got';
 import { LoopressCommand } from '../../lib/base.js';
+import { withSpinner } from '../../lib/spinner.js';
 import { pinVersion } from '../../types/plugin.js';
 import { compareVersions } from '../../utils/version.js';
 const WPVULN_BASE = 'https://www.wpvulnerability.net/plugin';
@@ -19,7 +20,7 @@ export default class Audit extends LoopressCommand {
         const advisories = [];
         const health = [];
         for (const slug of slugs) {
-            const found = await this.auditOne(slug, pinVersion(manifest[slug]));
+            const found = await withSpinner(`Auditing ${slug}`, async () => this.auditOne(slug, pinVersion(manifest[slug])));
             advisories.push(...found.advisories);
             health.push(...found.health);
         }
@@ -27,7 +28,12 @@ export default class Audit extends LoopressCommand {
     }
     async auditOne(slug, pinned) {
         const [vulns, info] = await Promise.all([this.fetchVulnerabilities(slug), this.fetchHealth(slug)]);
-        const advisories = vulns.filter((v) => pinned === 'latest' || affects(pinned, v.fixedIn)).map((v) => ({ ...v, slug }));
+        // "latest" is the newest WordPress.org release, the one a push installs: audit that version.
+        // Unknown (WordPress.org unreachable), every advisory is reported, safer than none.
+        const version = pinned === 'latest' && typeof info?.version === 'string' ? info.version : pinned;
+        const advisories = vulns
+            .filter((v) => version === 'latest' || affects(version, v.range))
+            .map(({ range: _range, ...v }) => ({ ...v, slug }));
         const health = info ? describeHealth(slug, pinned, info) : [];
         return { advisories, health };
     }
@@ -71,8 +77,13 @@ export default class Audit extends LoopressCommand {
         const noun = advisories.length === 1 ? 'advisory' : 'advisories';
         this.log(`\n${advisories.length} vulnerability ${noun}, ${health.length} health note(s). ` +
             'Vulnerability data: wpvulnerability.net.');
-        if (advisories.length > 0)
-            this.exit(1);
+        // exit() throws before oclif prints the --json result, which a CI reading it needs most here.
+        if (advisories.length > 0) {
+            if (this.jsonEnabled())
+                process.exitCode = 1;
+            else
+                this.exit(1);
+        }
         return { advisories, health, status: 'issues' };
     }
 }
@@ -85,34 +96,41 @@ function normalizeAdvisory(raw) {
     const cvss = (raw.cvss ?? {});
     const source = Array.isArray(raw.source) ? raw.source : [];
     const cve = typeof raw.cve === 'string' ? raw.cve : source.find((s) => s.id?.startsWith('CVE-'))?.id;
+    const range = extractRange(raw);
     return {
         cve,
-        fixedIn: extractFixedIn(raw),
+        fixedIn: range.max?.op === 'lt' ? range.max.version : undefined,
+        range,
         score: cvss.score,
         severity: cvss.severity,
-        title: typeof raw.name === 'string' ? raw.name : 'Unnamed advisory',
+        title: typeof raw.name === 'string' ? decodeEntities(raw.name) : 'Unnamed advisory',
     };
 }
-// wpvulnerability's `impact.software[].versions[]` carries `to_version` / `to_compare`; the
-// first "< X" bound is the version the fix landed in. Best-effort: the shape varies, so a
-// missing bound just means we can't tell and the advisory is reported anyway.
-function extractFixedIn(raw) {
-    const impact = raw.impact;
-    for (const sw of impact?.software ?? []) {
-        for (const v of sw.versions ?? []) {
-            if (v.to_compare === '<' && typeof v.to_version === 'string')
-                return v.to_version;
-        }
-    }
-    return undefined;
+// wpvulnerability's `operator`: `max_version` with `max_operator` "lt" (fixed in that version),
+// "le" (affected up to it, no fix yet) or "eq" (that version only), and an optional lower bound `min_version` with
+// `min_operator` "gt" or "ge". No upper bound means every version from the lower one on.
+function extractRange(raw) {
+    const op = (raw.operator ?? {});
+    const bound = (version, operator) => typeof version === 'string' && version !== '' && typeof operator === 'string' ? { op: operator, version } : undefined;
+    return { max: bound(op.max_version, op.max_operator), min: bound(op.min_version, op.min_operator) };
+}
+// A bound we can't evaluate (odd version strings, unknown operator) counts as affected: a false
+// positive is safer than hiding an advisory.
+function affects(version, range) {
+    const within = (bound, ok) => {
+        if (!bound)
+            return true;
+        const order = compareVersions(version, bound.version);
+        return order === null || !Object.hasOwn(ok, bound.op) || ok[bound.op](order);
+    };
+    return (within(range.min, { ge: (o) => o >= 0, gt: (o) => o > 0 }) && within(range.max, { eq: (o) => o === 0, le: (o) => o <= 0, lt: (o) => o < 0 }));
 }
-// If we know the fix version, a pin below it is affected. If we can't compare (odd version
-// strings), report it anyway: a false positive is safer than hiding an advisory.
-function affects(pinned, fixedIn) {
-    if (!fixedIn)
-        return true;
-    const order = compareVersions(pinned, fixedIn);
-    return order === null || order < 0;
+// Advisory names come HTML-encoded ("WPForms &#8211; AI Form Builder").
+function decodeEntities(text) {
+    return text
+        .replaceAll(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
+        .replaceAll('&quot;', '"')
+        .replaceAll('&amp;', '&');
 }
 function describeHealth(slug, pinned, info) {
     const notes = [];

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

@@ -7,4 +7,5 @@ export default class Config extends Command {
     private promptManualCredentials;
     private resolveCredentials;
     private resolveProject;
+    private sweepLeftoverTempAdmins;
 }

package/dist/commands/project/config.js

@@ -4,9 +4,12 @@ import { configManager } from '../../config/project-config.manager.js';
 import { bootstrapLoopressFull } from '../../lib/bootstrap-full-install.js';
 import { isInteractive } from '../../lib/interactive.js';
 import { isLoopressFullActive } from '../../lib/plugin-detection.js';
+import { withSpinner } from '../../lib/spinner.js';
+import { sweepTempAdmins } from '../../lib/temp-admin.js';
 import { authorizeWithBrowser } from '../../lib/wp-authorize-flow.js';
 import { isLocalEnvironment, WpClient } from '../../lib/wp-client.js';
 import { diagnoseWpSite } from '../../lib/wp-site-diagnostic.js';
+import { pluralize } from '../../utils/pluralize.js';
 const NEW_PROJECT = '__new__';
 const AUTH_BROWSER = 'browser';
 const AUTH_MANUAL = 'manual';
@@ -96,6 +99,10 @@ export default class Config extends Command {
         if (!token)
             return; // env was just built with one a few lines up; guard only narrows the type
         const wp = new WpClient(url, token, name);
+        // Before the "already active" early return: an install killed mid-way (SIGKILL, power loss)
+        // may have activated Full and still left its temp admin behind, and re-running this command
+        // is the documented fix for both.
+        await this.sweepLeftoverTempAdmins(wp);
         // A detection failure (network hiccup, plugins REST disabled) is treated as "assume it's
         // there" rather than surprising the user with an account-creating prompt they didn't ask
         // for; `lps project config` can simply be re-run if it genuinely isn't installed.
@@ -109,7 +116,9 @@ export default class Config extends Command {
         if (!isProceed)
             return;
         try {
-            await bootstrapLoopressFull(wp, url, (message) => { this.log(message); });
+            await withSpinner('Installing Loopress Full', async () => bootstrapLoopressFull(wp, url, (message) => {
+                this.log(message);
+            }));
         }
         catch (error) {
             this.warn(error.message);
@@ -181,4 +190,14 @@ export default class Config extends Command {
         });
         return { projectId: configManager.createProjectId(projectName.trim()), projectName: projectName.trim() };
     }
+    async sweepLeftoverTempAdmins(wp) {
+        try {
+            const removed = await sweepTempAdmins(wp);
+            if (removed.length > 0)
+                this.log(`✓ Removed ${pluralize(removed.length, 'leftover temporary admin account')}: ${removed.join(', ')}`);
+        }
+        catch (error) {
+            this.warn(error.message);
+        }
+    }
 }

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

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
 type EnvironmentInfo = {
-    isCurrent: boolean;
+    isDefault: boolean;
     name: string;
     url: string;
 };

package/dist/commands/project/list.js

@@ -14,15 +14,15 @@ export default class List extends Command {
         }
         return projects.map((project) => this.logProject(project));
     }
-    // Only name/url/isCurrent are surfaced, deliberately: EnvironmentConfig also carries the
+    // Only name/url/isDefault are surfaced, deliberately: EnvironmentConfig also carries the
     // WordPress application password token, which must never end up in --json output.
     logEnvironment(env) {
-        const envMarker = c(env.isCurrent ? 'cyan' : 'dim', '·');
-        const envName = c(env.isCurrent ? 'cyan' : 'dim', env.name.padEnd(15));
+        const envMarker = c(env.isDefault ? 'cyan' : 'dim', '·');
+        const envName = c(env.isDefault ? 'cyan' : 'dim', env.name.padEnd(15));
         const envUrl = c('dim', env.url);
-        const activeTag = env.isCurrent ? ` ${c('cyan', '←')}` : '';
-        this.log(`  ${envMarker} ${envName} ${envUrl}${activeTag}`);
-        return { isCurrent: env.isCurrent, name: env.name, url: env.url };
+        const defaultTag = env.isDefault ? ` ${c('cyan', '[default]')}` : '';
+        this.log(`  ${envMarker} ${envName} ${envUrl}${defaultTag}`);
+        return { isDefault: env.isDefault, name: env.name, url: env.url };
     }
     logProject(project) {
         const marker = project.isCurrent ? c('green', '●') : c('dim', '○');

package/dist/commands/project/pull.js

@@ -3,6 +3,7 @@ import { Listr } from 'listr2';
 import { authManager } from '../../config/auth.manager.js';
 import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
+import { withoutSpinner } from '../../lib/spinner.js';
 import { pluralize } from '../../utils/pluralize.js';
 export default class Pull extends Command {
     static description = 'Pull projects and environments from your Loopress account that are not configured locally yet';
@@ -23,14 +24,16 @@ export default class Pull extends Command {
         let projectCount = 0;
         let environmentCount = 0;
         if (newApiProjects.length > 0) {
-            await new Listr(newApiProjects.map((apiProject) => ({
-                task: (_ctx, task) => {
-                    this.pullProject(apiProject, task);
-                    projectCount++;
-                    environmentCount += apiProject.environments.length;
-                },
-                title: `Pull project "${apiProject.name}" from the API`,
-            })), { concurrent: false, exitOnError: false }).run();
+            await withoutSpinner(async () => {
+                await new Listr(newApiProjects.map((apiProject) => ({
+                    task: (_ctx, task) => {
+                        this.pullProject(apiProject, task);
+                        projectCount++;
+                        environmentCount += apiProject.environments.length;
+                    },
+                    title: `Pull project "${apiProject.name}" from the API`,
+                })), { concurrent: false, exitOnError: false }).run();
+            });
         }
         this.log(`\n✓ Pulled ${pluralize(projectCount, 'project')}, ${pluralize(environmentCount, 'environment')} from your Loopress account`);
     }

package/dist/commands/project/push.js

@@ -6,6 +6,7 @@ import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
 import { LoopressCommand } from '../../lib/base.js';
 import { isInteractive } from '../../lib/interactive.js';
+import { withoutSpinner } from '../../lib/spinner.js';
 import { pluralize } from '../../utils/pluralize.js';
 import { toSlug } from '../../utils/to-slug.js';
 export default class Push extends Command {
@@ -66,15 +67,17 @@ export default class Push extends Command {
         if (envsNeedingWork.length === 0)
             return 0;
         let count = 0;
-        await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
-            task: async (_ctx, task) => {
-                await this.applyEnvironment(api, apiProjectId, envPlan, task);
-                count++;
-            },
-            title: envPlan.action === 'create'
-                ? `Create environment "${envPlan.env.name}" on "${projectName}"`
-                : `Link environment "${envPlan.env.name}" on "${projectName}"`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await withoutSpinner(async () => {
+            await new Listr(envsNeedingWork.map(({ apiProjectId, envPlan, projectName }) => ({
+                task: async (_ctx, task) => {
+                    await this.applyEnvironment(api, apiProjectId, envPlan, task);
+                    count++;
+                },
+                title: envPlan.action === 'create'
+                    ? `Create environment "${envPlan.env.name}" on "${projectName}"`
+                    : `Link environment "${envPlan.env.name}" on "${projectName}"`,
+            })), { concurrent: false, exitOnError: false }).run();
+        });
         return count;
     }
     async applyProject(api, plan, task) {
@@ -101,15 +104,17 @@ export default class Push extends Command {
         if (projectsNeedingWork.length === 0)
             return 0;
         let count = 0;
-        await new Listr(projectsNeedingWork.map((plan) => ({
-            task: async (_ctx, task) => {
-                await this.applyProject(api, plan, task);
-                count++;
-            },
-            title: plan.action === 'create'
-                ? `Create project "${plan.project.name}" on the API`
-                : `Link project "${plan.project.name}" to the API`,
-        })), { concurrent: false, exitOnError: false }).run();
+        await withoutSpinner(async () => {
+            await new Listr(projectsNeedingWork.map((plan) => ({
+                task: async (_ctx, task) => {
+                    await this.applyProject(api, plan, task);
+                    count++;
+                },
+                title: plan.action === 'create'
+                    ? `Create project "${plan.project.name}" on the API`
+                    : `Link project "${plan.project.name}" to the API`,
+            })), { concurrent: false, exitOnError: false }).run();
+        });
         return count;
     }
     collectEnvsNeedingWork(projectPlans, envPlansByProject) {

package/dist/commands/project/remove.js

@@ -24,7 +24,7 @@ export default class Remove extends Command {
             const envChoices = configManager.listEnvironments(project.id).map((env) => {
                 targets.push({ env: env.name, kind: 'env', projectId: project.id, projectName: project.name });
                 return {
-                    name: `    ${env.name.padEnd(20)} ${env.url}${env.isCurrent ? ' [current]' : ''}`,
+                    name: `    ${env.name.padEnd(20)} ${env.url}`,
                     value: String(targets.length - 1),
                 };
             });

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

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

package/dist/commands/project/switch.js

@@ -1,9 +1,8 @@
-import { select, Separator } from '@inquirer/prompts';
-import { Command, ux } from '@oclif/core';
+import { select } from '@inquirer/prompts';
+import { Command } from '@oclif/core';
 import { configManager } from '../../config/project-config.manager.js';
-const c = ux.colorize;
 export default class Switch extends Command {
-    static description = 'Switch the active project and environment';
+    static description = 'Switch the active project (pass --env to target a non-local environment)';
     static examples = ['$ lps project switch'];
     async run() {
         await this.parse(Switch);
@@ -11,37 +10,18 @@ export default class Switch extends Command {
         if (projects.length === 0) {
             this.error('No projects configured. Run `lps project config` first.');
         }
-        const { envName, projectId, projectName } = await this.resolveSelection(projects);
-        configManager.setCurrent(projectId, envName);
-        this.log(`✓ Switched to "${projectName}/${envName}"`);
-    }
-    async resolveSelection(projects) {
-        const groups = projects
-            .map((project) => ({ envs: configManager.listEnvironments(project.id), project }))
-            .filter(({ envs }) => envs.length > 0);
-        if (groups.length === 0) {
-            this.error('No environments configured. Run `lps project config` first.');
-        }
-        const entries = groups.flatMap(({ envs, project }) => envs.map((env) => ({ env, project })));
-        if (entries.length === 1) {
-            const { env, project } = entries[0];
-            return { envName: env.name, projectId: project.id, projectName: project.name };
-        }
-        const choices = groups.flatMap(({ envs, project }) => [
-            new Separator(c(project.isCurrent ? 'green' : 'dim', `─── ${project.name} ───`)),
-            ...envs.map((env) => ({
-                name: `${env.name.padEnd(20)} ${env.url}${env.isCurrent ? ' [current]' : ''}`,
-                value: `${project.id}::${env.name}`,
-            })),
-        ]);
-        const current = entries.find(({ env }) => env.isCurrent);
-        const chosen = await select({
-            choices,
-            default: current && `${current.project.id}::${current.env.name}`,
-            message: 'Select project / environment',
-        });
-        const [projectId, envName] = chosen.split('::', 2);
-        const { project } = groups.find((group) => group.project.id === projectId);
-        return { envName, projectId, projectName: project.name };
+        const projectId = projects.length === 1
+            ? projects[0].id
+            : await select({
+                choices: projects.map((project) => ({
+                    name: `${project.name}${project.isCurrent ? ' [current]' : ''}`,
+                    value: project.id,
+                })),
+                default: projects.find((project) => project.isCurrent)?.id,
+                message: 'Select project',
+            });
+        configManager.setCurrent(projectId);
+        const project = projects.find((candidate) => candidate.id === projectId);
+        this.log(`✓ Switched to "${project.name}"`);
     }
 }

package/dist/commands/promote.d.ts

@@ -13,6 +13,7 @@ export default class Promote extends Command {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/promote.js

@@ -8,6 +8,7 @@ import { configManager } from '../config/project-config.manager.js';
 import { LoopressCommand } from '../lib/base.js';
 import { isInteractive } from '../lib/interactive.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
+import { PushCommand } from '../lib/push-command.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
 import { resolveResourceDir, RESOURCE_DIR_DEFAULTS } from '../utils/resource-dirs.js';
 export default class Promote extends Command {
@@ -21,10 +22,11 @@ export default class Promote extends Command {
     static flags = {
         ...LoopressCommand.dryRunFlag,
         ...LoopressCommand.yesFlag,
+        overwrite: PushCommand.baseFlags.overwrite,
     };
     async run() {
         const { args, flags } = await this.parse(Promote);
-        const { yes } = flags;
+        const { overwrite, yes } = flags;
         const dryRun = flags['dry-run'];
         const { environments, projectName } = await this.resolveProject();
         const from = this.requireEnvironment(environments, projectName, args.from);
@@ -52,10 +54,12 @@ export default class Promote extends Command {
             }
             catch (error) {
                 // A partial pull must never be pushed onward: stop before touching <to>.
-                this.error(`Pull from ${from.name} failed, ${to.name} left untouched: ${error.message}`);
+                // "untouched" is only true of <to>: a real (non dry-run) pull has already rewritten the files.
+                const filesNote = dryRun ? '' : ` Your local files may already hold part of ${from.name}, review them before pushing.`;
+                this.error(`Pull from ${from.name} failed, nothing was pushed to ${to.name}.${filesNote} ${error.message}`);
             }
             this.log(`\n=== Pushing to ${to.name} (${to.url}) ===`);
-            await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', this.delegateArgv(to.name, dryRun)));
+            await stdoutToStderr(this.jsonEnabled(), async () => this.config.runCommand('push', [...this.delegateArgv(to.name, dryRun), ...(overwrite ? ['--overwrite'] : [])]));
         }
         finally {
             if (scratch) {

package/dist/commands/pull.d.ts

@@ -2,7 +2,7 @@ import { LoopressCommand } from '../lib/base.js';
 type PullTargetResult = {
     error?: string;
     label: string;
-    status: 'failed' | 'pulled';
+    status: 'failed' | 'pulled' | 'skipped';
 };
 type PullResult = {
     results: PullTargetResult[];
@@ -18,5 +18,6 @@ export default class Pull extends LoopressCommand {
     private failedCount;
     run(): Promise<PullResult>;
     private buildArgv;
+    private usesResource;
 }
 export {};

package/dist/commands/pull.js

@@ -1,23 +1,33 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { LoopressCommand } from '../lib/base.js';
 import { stdoutToStderr } from '../lib/json-delegation.js';
 import { pluralize } from '../utils/pluralize.js';
+import { resolveResourceDir } from '../utils/resource-dirs.js';
+// How the plugin reports its integration missing: "ACF is not active", "No supported form
+// plugin is active", "No supported snippet plugin is active".
+const PLUGIN_MISSING = /\bis not active\b|\bNo supported .+ plugin is active\b/;
 // composer before plugins: when a composer.json exists, `plugin:pull` merges the live plugins
 // into it, so it must run on the freshly pulled one or `composer:pull` would overwrite its work. The rest write to independent
 // directories and their order does not matter, it mirrors `lps push` for familiarity.
 const PULL_TARGETS = [
     { commandId: 'composer:pull', label: 'composer' },
     { commandId: 'plugin:pull', label: 'plugins' },
-    { commandId: 'acf:pull', label: 'ACF', supportsYes: true },
+    { commandId: 'cpt:pull', label: 'post types', supportsYes: true },
+    { commandId: 'taxonomy:pull', label: 'taxonomies', supportsYes: true },
+    { commandId: 'meta:pull', label: 'post meta', supportsYes: true },
+    { commandId: 'role:pull', label: 'roles', supportsYes: true },
+    { commandId: 'acf:pull', label: 'ACF', needsPlugin: 'acf', supportsYes: true },
     { commandId: 'api:pull', label: 'API routes', supportsYes: true },
     { commandId: 'hook:pull', label: 'hooks', supportsYes: true },
-    { commandId: 'form:pull', label: 'forms', supportsYes: true },
-    { commandId: 'seo:pull', label: 'SEO', supportsYes: true },
+    { commandId: 'form:pull', label: 'forms', needsPlugin: 'form', supportsYes: true },
+    { commandId: 'pattern:pull', label: 'patterns', supportsYes: true },
     { commandId: 'menu:pull', label: 'menus', supportsYes: true },
     { commandId: 'option:pull', label: 'options', supportsYes: true },
-    { commandId: 'snippet:pull', label: 'snippets', supportsYes: true },
+    { commandId: 'snippet:pull', label: 'snippets', needsPlugin: 'snippets', supportsYes: true },
 ];
 export default class Pull extends LoopressCommand {
-    static description = 'Pull all content, plugins, composer dependencies, ACF, API routes, hooks, forms, SEO, menus, options, and snippets, from WordPress';
+    static description = 'Pull all content, plugins, composer dependencies, post types, taxonomies, post meta, roles, ACF, API routes, hooks, forms, patterns, menus, options, and snippets, from WordPress';
     static enableJsonFlag = true;
     static examples = ['$ lps pull', '$ lps pull --env staging', '$ lps pull --dry-run'];
     static flags = {
@@ -27,6 +37,7 @@ export default class Pull extends LoopressCommand {
     failedCount = 0;
     async run() {
         const results = [];
+        this.warnRemovedSeoModule();
         for (const target of PULL_TARGETS) {
             this.log(`\n→ Pulling ${target.label}...`);
             try {
@@ -35,8 +46,19 @@ export default class Pull extends LoopressCommand {
                 results.push({ label: target.label, status: 'pulled' });
             }
             catch (error) {
-                this.failedCount++;
                 const { message } = error;
+                // A site without ACF (or a form or snippet plugin) is the common case, not a failure,
+                // as long as the project doesn't use that resource: a vanilla site must pull, and a
+                // promote must not stop on it. A project that does use it still fails.
+                if (target.needsPlugin && PLUGIN_MISSING.test(message) && !this.usesResource(target.needsPlugin)) {
+                    // oclif's catch already set exitCode to 1 for the sub-command; a real failure still
+                    // exits non-zero through the this.error() below.
+                    process.exitCode = undefined;
+                    this.log(`→ ${target.label}: not configured, skipped`);
+                    results.push({ label: target.label, status: 'skipped' });
+                    continue;
+                }
+                this.failedCount++;
                 this.log(`✗ ${target.label} failed: ${message}`);
                 results.push({ error: message, label: target.label, status: 'failed' });
             }
@@ -60,4 +82,7 @@ export default class Pull extends LoopressCommand {
             argv.push('--yes');
         return argv;
     }
+    usesResource(kind) {
+        return existsSync(resolve(resolveResourceDir(kind, this.localConfig)));
+    }
 }

package/dist/commands/push.d.ts

@@ -2,7 +2,7 @@ import { LoopressCommand } from '../lib/base.js';
 type PushTargetResult = {
     error?: string;
     label: string;
-    status: 'failed' | 'pushed';
+    status: 'failed' | 'pushed' | 'skipped';
 };
 type PushResult = {
     results: PushTargetResult[];
@@ -12,13 +12,15 @@ export default class Push extends LoopressCommand {
     static enableJsonFlag: boolean;
     static examples: string[];
     static flags: {
+        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private failedCount;
     run(): Promise<PushResult>;
     private buildArgv;
     private composerDeclaresPlugins;
+    private composerJsonPath;
     private guardProductionPush;
+    private skippedTargets;
 }
 export {};