@loopress/cli 0.14.0 → 0.16.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/project/pull.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class Pull extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private fetchApiProjects;
+    private pullProject;
+}

package/dist/commands/project/pull.js

@@ -0,0 +1,69 @@
+import { Command } from '@oclif/core';
+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';
+export default class Pull extends Command {
+    static description = 'Pull projects and environments from your Loopress account that are not configured locally yet';
+    static examples = ['$ lps project pull'];
+    async run() {
+        await this.parse(Pull);
+        const token = authManager.getAuth()?.token;
+        if (!token) {
+            this.error('Not logged in. Run `lps login` first.');
+        }
+        const api = new ApiClient(token);
+        const apiProjects = await this.fetchApiProjects(api);
+        const linkedApiProjectIds = new Set(configManager
+            .listProjects()
+            .map((project) => project.apiProjectId)
+            .filter((id) => id !== undefined));
+        const newApiProjects = apiProjects.filter((apiProject) => !linkedApiProjectIds.has(apiProject.id));
+        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();
+        }
+        this.log(`\n✓ Pulled ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} from your Loopress account`);
+    }
+    async fetchApiProjects(api) {
+        try {
+            return await api.get('projects');
+        }
+        catch (error) {
+            this.error(`Could not fetch projects from the API: ${error.message}`);
+        }
+    }
+    // Reuse a local project already linked to this API project instead of always minting a new
+    // one: otherwise every pull that can't "claim" an existing link (e.g. after the local config
+    // was reset or desynced from the API) creates yet another duplicate entry.
+    pullProject(apiProject, task) {
+        const existing = configManager.findProjectByApiId(apiProject.id);
+        const environments = { ...existing?.environments };
+        for (const env of apiProject.environments) {
+            environments[env.name] = {
+                ...environments[env.name],
+                addedAt: environments[env.name]?.addedAt ?? env.createdAt,
+                apiEnvironmentId: env.id,
+                name: env.name,
+                url: env.url,
+            };
+        }
+        configManager.setProject(existing?.id ?? configManager.createProjectId(apiProject.name), {
+            addedAt: existing?.addedAt ?? apiProject.createdAt,
+            apiProjectId: apiProject.id,
+            environments,
+            name: apiProject.name,
+        });
+        const envCount = apiProject.environments.length;
+        if (task)
+            task.output = `Pulled with ${envCount} environment${envCount === 1 ? '' : 's'}`;
+    }
+}

package/dist/commands/project/{sync.d.ts → push.d.ts}

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-export default class Sync extends Command {
+export default class Push extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
@@ -8,6 +8,5 @@ export default class Sync extends Command {
     private fetchApiProjects;
     private planEnvironment;
     private planProject;
-    private pullProject;
     private pushCredentials;
 }

package/dist/commands/project/{sync.js → push.js}

@@ -5,11 +5,11 @@ import slugify from 'slugify';
 import { authManager } from '../../config/auth.manager.js';
 import { configManager } from '../../config/project-config.manager.js';
 import { ApiClient } from '../../lib/api-client.js';
-export default class Sync extends Command {
-    static description = 'Sync locally configured projects and environments with your Loopress account';
-    static examples = ['$ lps project sync'];
+export default class Push extends Command {
+    static description = 'Push locally configured projects, environments and credentials to your Loopress account';
+    static examples = ['$ lps project push'];
     async run() {
-        await this.parse(Sync);
+        await this.parse(Push);
         const token = authManager.getAuth()?.token;
         if (!token) {
             this.error('Not logged in. Run `lps login` first.');
@@ -77,22 +77,11 @@ export default class Sync extends Command {
                     await this.pushCredentials(api, plan.apiProjectId, envPlan.apiEnvironmentId, envPlan.env);
                 }
                 catch (error) {
-                    this.warn(`Failed to sync "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
+                    this.warn(`Failed to push "${plan.project.name}/${envPlan.env.name}": ${error.message}`);
                 }
             }
         }
-        const newApiProjects = apiProjects.filter((candidate) => !claimedProjectIds.has(candidate.id));
-        if (newApiProjects.length > 0) {
-            await new Listr(newApiProjects.map((apiProject) => ({
-                task: async (_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✓ Synced ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} with your Loopress account`);
+        this.log(`\n✓ Pushed ${projectCount} project${projectCount === 1 ? '' : 's'}, ${environmentCount} environment${environmentCount === 1 ? '' : 's'} to your Loopress account`);
     }
     async applyEnvironment(api, apiProjectId, envPlan, task) {
         try {
@@ -111,7 +100,7 @@ export default class Sync extends Command {
                 task.output = envPlan.action === 'create' ? 'Created on the API' : 'Linked to the API';
         }
         catch (error) {
-            const message = `Failed to sync "${envPlan.env.name}": ${error.message}`;
+            const message = `Failed to push "${envPlan.env.name}": ${error.message}`;
             if (task)
                 task.output = message;
             throw error;
@@ -131,7 +120,7 @@ export default class Sync extends Command {
                 task.output = plan.action === 'create' ? 'Created on the API' : 'Linked to the API';
         }
         catch (error) {
-            const message = `Failed to sync project "${plan.project.name}": ${error.message}`;
+            const message = `Failed to push project "${plan.project.name}": ${error.message}`;
             if (task)
                 task.output = message;
             throw error;
@@ -183,31 +172,6 @@ export default class Sync extends Command {
         }
         return { action: 'create', project };
     }
-    pullProject(apiProject, task) {
-        // Reuse a local project already linked to this API project instead of always minting a
-        // new one: otherwise every sync run that can't "claim" an existing link (e.g. after the
-        // local config was reset or desynced from the API) creates yet another duplicate entry.
-        const existing = configManager.findProjectByApiId(apiProject.id);
-        const environments = { ...existing?.environments };
-        for (const env of apiProject.environments) {
-            environments[env.name] = {
-                ...environments[env.name],
-                addedAt: environments[env.name]?.addedAt ?? env.createdAt,
-                apiEnvironmentId: env.id,
-                name: env.name,
-                url: env.url,
-            };
-        }
-        configManager.setProject(existing?.id ?? configManager.createProjectId(apiProject.name), {
-            addedAt: existing?.addedAt ?? apiProject.createdAt,
-            apiProjectId: apiProject.id,
-            environments,
-            name: apiProject.name,
-        });
-        const envCount = apiProject.environments.length;
-        if (task)
-            task.output = `Pulled with ${envCount} environment${envCount === 1 ? '' : 's'}`;
-    }
     async pushCredentials(api, apiProjectId, apiEnvironmentId, env) {
         if (!env.token)
             return;

package/dist/commands/snippet/publish.js

@@ -32,7 +32,7 @@ export default class Publish extends Command {
             this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
         }
         if (!project.apiProjectId) {
-            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project sync\` first.`);
+            this.error(`Project "${project.name}" is not linked to your Loopress account yet. Run \`lps project push\` first.`);
         }
         const path = args.path ?? join(localConfig.rootDir ?? '.', localConfig.snippetsDir ?? 'snippets');
         this.log(`Publishing snippets from ${path}`);

package/dist/config/project-config.manager.js

@@ -24,10 +24,10 @@ export class ProjectConfigManager {
             mkdirSync(dir, { recursive: true });
         }
     }
-    // Looks up a local project already linked to a given API project, regardless of whether
-    // it was "claimed" in the current sync run. Used by `project sync` to avoid minting a new
-    // local project every time it pulls an API project whose local link was lost (e.g. after
-    // a reset or partial config corruption), which otherwise accumulates duplicate entries.
+    // Looks up a local project already linked to a given API project. Used by `project pull` to
+    // avoid minting a new local project every time it pulls an API project whose local link was
+    // lost (e.g. after a reset or partial config corruption), which otherwise accumulates
+    // duplicate entries.
     findProjectByApiId(apiProjectId) {
         const config = this.readConfig();
         for (const [id, project] of Object.entries(config.projects)) {

package/dist/help.js

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

package/dist/hooks/finally.js

@@ -1,4 +1,4 @@
-import { isTelemetryDisabled, resolveEnvironment, runtimeContext, SENTRY_DSN } from '../lib/sentry.js';
+import { isTelemetryDisabled, redactArgv, resolveEnvironment, runtimeContext, SENTRY_DSN, } from '../lib/sentry.js';
 // oclif has no `command_error` hook (checked @oclif/core@4.11.11's hooks.d.ts). `finally`
 // is the closest equivalent: it always runs at the end of the CLI lifecycle and carries
 // the error, if any, so it's where we report crashes before the process exits.
@@ -15,10 +15,15 @@ const hook = async function (options) {
             dsn: SENTRY_DSN,
             environment: resolveEnvironment(),
             release: this.config.version,
+            // Node defaults `server_name` to os.hostname(), which is often the user's real name
+            // (e.g. "jane-doe-macbook-pro"). sendDefaultPii covers IP addresses and similar, off by
+            // default but set explicitly since this reports from users' own machines.
+            sendDefaultPii: false,
+            serverName: 'loopress',
         });
         Sentry.captureException(options.error, {
             contexts: { runtime: runtimeContext() },
-            extra: { argv: options.argv },
+            extra: { argv: redactArgv(options.argv) },
             tags: { command: options.id },
         });
         await Sentry.flush(2000);

package/dist/lib/base.d.ts

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

package/dist/lib/base.js

@@ -35,6 +35,11 @@ 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');
+    }
     resolveSnippetsPath(override) {
         if (override)
             return override;

package/dist/lib/sentry.d.ts

@@ -5,3 +5,4 @@ export declare function runtimeContext(): {
     node: string;
     os: string;
 };
+export declare function redactArgv(argv: string[]): string[];

package/dist/lib/sentry.js

@@ -20,3 +20,14 @@ export function runtimeContext() {
         os: `${platform()} ${release()}`,
     };
 }
+// Positional args and flag values can carry WordPress URLs, usernames, application passwords,
+// or tokens (e.g. `lps login --token xxx`, `lps project config <url>`). Only flag names are
+// safe to report, they help tell which code path crashed without leaking what was passed to it.
+export function redactArgv(argv) {
+    return argv.map((arg) => {
+        if (!arg.startsWith('-'))
+            return '[REDACTED]';
+        const eqIndex = arg.indexOf('=');
+        return eqIndex === -1 ? arg : arg.slice(0, eqIndex);
+    });
+}

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

@@ -30,7 +30,7 @@ export interface ProjectConfig {
      */
     addedAt: string;
     /**
-     * Id of the matching project on the Loopress API, once synced via `lps project sync`.
+     * Id of the matching project on the Loopress API, once pushed via `lps project push`.
      */
     apiProjectId?: string;
     /**
@@ -50,7 +50,7 @@ export interface EnvironmentConfig {
      */
     addedAt: string;
     /**
-     * Id of the matching environment on the Loopress API, once synced via `lps project sync`.
+     * Id of the matching environment on the Loopress API, once pushed via `lps project push`.
      */
     apiEnvironmentId?: string;
     /**

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

@@ -11,6 +11,10 @@ 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;
     /**
      * 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]));