@loopress/cli 0.22.0 → 0.24.0

package/dist/utils/plugin-sync.js

@@ -0,0 +1,31 @@
+// Shared helpers for driving the server-side `loopress/v1/composer/sync` endpoint, used by
+// `lps plugin push`, `lps theme push` and `lps composer push`. The endpoint runs Composer +
+// WPackagist inside WordPress; the CLI only ever sends intent (which slugs at which versions),
+// never a composer.json, so the plugin stays the single authority on that file's shape.
+import { compareVersions } from './version.js';
+// A cold `composer update` on a fresh site easily exceeds the global 30s WpClient timeout.
+export const SYNC_TIMEOUT_MS = 600_000;
+// 422 from the sync endpoint when the intent references a plugin/theme whose folder already
+// exists on the site but isn't tracked in composer.lock (installed by hand through wp-admin).
+// Re-running with --force lets the server remove the folder so Composer can take it over.
+export function parseCollisions(error) {
+    const body = error.cause?.response;
+    if (body?.statusCode !== 422 || !body.body)
+        return null;
+    try {
+        const parsed = JSON.parse(body.body);
+        if (parsed.error === 'unmanaged_plugins_present' && Array.isArray(parsed.collisions)) {
+            return parsed.collisions;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+// Only gates whether a version change needs --force. Unorderable inputs ("latest", a
+// constraint) count as "not a downgrade" so they don't block the push.
+export function isDowngrade(from, to) {
+    const order = compareVersions(to, from);
+    return order !== null && order < 0;
+}

package/dist/utils/plugins.d.ts

@@ -1,13 +1,25 @@
 import { type InstalledPlugin, type PluginManifest, type WpNativePlugin } from '../types/plugin.js';
 export type PluginDiff = {
+    collisions: Array<{
+        installedVersion: string;
+        slug: string;
+    }>;
+    inSync: string[];
     toActivate: Array<{
         file: string;
         slug: string;
     }>;
     toInstall: Array<{
         slug: string;
+        version: string;
+    }>;
+    toPin: Array<{
+        from: string;
+        slug: string;
+        to: string;
     }>;
-    upToDate: string[];
+    toRemove: string[];
+    untrackedActive: string[];
 };
 export type MergeResult = {
     added: string[];
@@ -20,4 +32,5 @@ export type MergeResult = {
 };
 export declare function mergePluginManifest(existing: PluginManifest, incoming: PluginManifest): MergeResult;
 export declare function parseInstalledPlugins(raw: WpNativePlugin[]): InstalledPlugin[];
-export declare function diffPlugins(manifest: PluginManifest, installed: InstalledPlugin[]): PluginDiff;
+export declare function diffPlugins(manifest: PluginManifest, installed: InstalledPlugin[], managedSlugs?: Set<string>): PluginDiff;
+export declare function lockedWpackagistSlugs(composerLock: null | string, kind: 'plugin' | 'theme'): Set<string>;

package/dist/utils/plugins.js

@@ -14,9 +14,18 @@ export function mergePluginManifest(existing, incoming) {
 }
 // WordPress core identifies each plugin by a `<folder>/<file>` id (or a bare `<file>` for a
 // single-file plugin) with the `.php` extension stripped; the WordPress.org slug is just the
-// folder name (or the bare id itself for a single-file plugin).
-function slugFromPluginFile(file) {
-    return file.split('/', 1)[0];
+// folder name (or the bare id itself for a single-file plugin). Composer + composer/installers
+// installs a WPackagist plugin into `wp-content/plugins/<slug>/`, so folder name and slug stay
+// aligned for anything Loopress manages.
+//
+// A single-file plugin's bare id isn't always its real slug though: Hello Dolly ships as
+// `hello.php` but its WordPress.org (and WPackagist) slug is `hello-dolly`. When that happens,
+// trust the plugin's own `Plugin URI` header over the guessed id.
+const WP_ORG_PLUGIN_URI = /^https?:\/\/wordpress\.org\/plugins\/([^/]+)\/?$/;
+function slugFromPluginFile(file, pluginUri) {
+    if (file.includes('/'))
+        return file.split('/', 1)[0];
+    return WP_ORG_PLUGIN_URI.exec(pluginUri)?.[1] ?? file;
 }
 export function parseInstalledPlugins(raw) {
     return raw
@@ -24,27 +33,63 @@ export function parseInstalledPlugins(raw) {
         active: item.status !== 'inactive',
         file: item.plugin,
         name: item.name,
-        slug: slugFromPluginFile(item.plugin),
+        slug: slugFromPluginFile(item.plugin, item.plugin_uri),
         version: item.version,
     }))
         .filter((plugin) => !LOOPRESS_PLUGIN_SLUGS.has(plugin.slug));
 }
-export function diffPlugins(manifest, installed) {
+export function diffPlugins(manifest, installed, 
+// Slugs Loopress currently manages, from the local composer.lock's wpackagist-plugin/*
+// entries. Empty for a loopress.json-only project that doesn't keep a lockfile in the repo:
+// `toRemove` then stays empty (removals still happen server-side, they just aren't previewed).
+managedSlugs = new Set()) {
     const installedMap = new Map(installed.map((p) => [p.slug, p]));
     const toInstall = [];
+    const toPin = [];
     const toActivate = [];
-    const upToDate = [];
-    for (const slug of Object.keys(manifest)) {
+    const collisions = [];
+    const inSync = [];
+    for (const [slug, wanted] of Object.entries(manifest)) {
         const live = installedMap.get(slug);
         if (!live) {
-            toInstall.push({ slug });
+            toInstall.push({ slug, version: wanted });
+            continue;
         }
-        else if (live.active) {
-            upToDate.push(slug);
+        // Installed, but Loopress doesn't own the folder yet: nothing else can be done with it
+        // until `--force` lets Composer take it over.
+        if (!managedSlugs.has(slug)) {
+            collisions.push({ installedVersion: live.version, slug });
+            continue;
         }
-        else {
+        if (wanted !== 'latest' && live.version !== wanted) {
+            toPin.push({ from: live.version, slug, to: wanted });
+            continue;
+        }
+        if (!live.active) {
             toActivate.push({ file: live.file, slug });
+            continue;
         }
+        inSync.push(slug);
+    }
+    const toRemove = [...managedSlugs].filter((slug) => !Object.hasOwn(manifest, slug));
+    const untrackedActive = installed
+        .filter((p) => p.active && !Object.hasOwn(manifest, p.slug) && !managedSlugs.has(p.slug))
+        .map((p) => p.slug);
+    return { collisions, inSync, toActivate, toInstall, toPin, toRemove, untrackedActive };
+}
+// wpackagist-plugin/<slug> or wpackagist-theme/<slug> entries from a composer.lock string.
+export function lockedWpackagistSlugs(composerLock, kind) {
+    if (!composerLock)
+        return new Set();
+    const prefix = `wpackagist-${kind}/`;
+    try {
+        const parsed = JSON.parse(composerLock);
+        return new Set((parsed.packages ?? [])
+            .map((p) => p.name ?? '')
+            .filter((name) => name.startsWith(prefix))
+            .map((name) => name.slice(prefix.length)));
+    }
+    catch {
+        return new Set();
     }
-    return { toActivate, toInstall, upToDate };
 }

package/dist/utils/resource-dirs.d.ts

@@ -0,0 +1,13 @@
+import { type LoopressLocalConfig } from './loopress-config.js';
+export declare const RESOURCE_DIR_DEFAULTS: {
+    readonly acf: "acf";
+    readonly api: "api";
+    readonly apps: "apps";
+    readonly form: "forms";
+    readonly hooks: "hooks";
+    readonly options: "options";
+    readonly seo: "seo";
+    readonly snippets: "snippets";
+};
+export type ResourceDirKind = keyof typeof RESOURCE_DIR_DEFAULTS;
+export declare function resolveResourceDir(kind: ResourceDirKind, localConfig: LoopressLocalConfig, override?: string): string;

package/dist/utils/resource-dirs.js

@@ -0,0 +1,34 @@
+import { join } from 'node:path';
+// The default subdirectory for each file-backed resource, relative to rootDir. `lps init`
+// writes these same defaults into loopress.json, keep the two in sync.
+export const RESOURCE_DIR_DEFAULTS = {
+    acf: 'acf',
+    api: 'api',
+    apps: 'apps',
+    form: 'forms',
+    hooks: 'hooks',
+    options: 'options',
+    seo: 'seo',
+    snippets: 'snippets',
+};
+const CONFIG_KEY = {
+    acf: 'acfDir',
+    api: 'apiDir',
+    apps: 'appsDir',
+    form: 'formDir',
+    hooks: 'hooksDir',
+    options: 'optionsDir',
+    seo: 'seoDir',
+    snippets: 'snippetsDir',
+};
+// Resolves where a resource's files live: an explicit override wins, otherwise the
+// loopress.json `<kind>Dir` setting, otherwise the built-in default, all under `rootDir`.
+// Shared by every pull/push command (via LoopressCommand's resolve*Path helpers) and by
+// `lps diff`, so the resolution rule has a single home.
+export function resolveResourceDir(kind, localConfig, override) {
+    if (override)
+        return override;
+    const rootDir = localConfig.rootDir ?? '.';
+    const configured = localConfig[CONFIG_KEY[kind]];
+    return join(rootDir, configured ?? RESOURCE_DIR_DEFAULTS[kind]);
+}

package/dist/utils/themes.d.ts

@@ -0,0 +1,30 @@
+export type WpNativeTheme = {
+    status: 'active' | 'inactive';
+    stylesheet: string;
+    version: string;
+};
+export type InstalledTheme = {
+    active: boolean;
+    slug: string;
+    version: string;
+};
+export type ThemeManifest = Record<string, string>;
+export type ThemeDiff = {
+    collisions: Array<{
+        installedVersion: string;
+        slug: string;
+    }>;
+    inSync: string[];
+    toInstall: Array<{
+        slug: string;
+        version: string;
+    }>;
+    toPin: Array<{
+        from: string;
+        slug: string;
+        to: string;
+    }>;
+    toRemove: string[];
+};
+export declare function parseInstalledThemes(raw: WpNativeTheme[]): InstalledTheme[];
+export declare function diffThemes(manifest: ThemeManifest, installed: InstalledTheme[], managedSlugs?: Set<string>): ThemeDiff;

package/dist/utils/themes.js

@@ -0,0 +1,29 @@
+// Themes are version-managed only: Loopress never switches the active theme (that can break a
+// live site hard), so unlike plugins there is no activate / prune dimension here.
+export function parseInstalledThemes(raw) {
+    return raw.map((t) => ({ active: t.status === 'active', slug: t.stylesheet, version: t.version }));
+}
+export function diffThemes(manifest, installed, managedSlugs = new Set()) {
+    const map = new Map(installed.map((t) => [t.slug, t]));
+    const toInstall = [];
+    const toPin = [];
+    const collisions = [];
+    const inSync = [];
+    for (const [slug, wanted] of Object.entries(manifest)) {
+        const live = map.get(slug);
+        if (!live) {
+            toInstall.push({ slug, version: wanted });
+        }
+        else if (!managedSlugs.has(slug)) {
+            collisions.push({ installedVersion: live.version, slug });
+        }
+        else if (wanted !== 'latest' && live.version !== wanted) {
+            toPin.push({ from: live.version, slug, to: wanted });
+        }
+        else {
+            inSync.push(slug);
+        }
+    }
+    const toRemove = [...managedSlugs].filter((slug) => !Object.hasOwn(manifest, slug));
+    return { collisions, inSync, toInstall, toPin, toRemove };
+}

package/dist/utils/version.d.ts

@@ -0,0 +1,2 @@
+export declare function isExactVersion(value: string): boolean;
+export declare function compareVersions(a: string, b: string): null | number;

package/dist/utils/version.js

@@ -0,0 +1,21 @@
+import { compareVersions as cmp, validate } from 'compare-versions';
+// An exact version like 9.4.2 or 3.0.0-beta1, not a Composer constraint (^, ~, *, ranges,
+// ||, x-wildcards). loopress.json pins an exact version or the literal "latest"; a constraint
+// breaks the CLI's drift detection (it never string-equals the resolved version), so it is
+// rejected at `add` time. Not `compare-versions`' `validate()`: that accepts "9.4.x".
+//
+// A prerelease suffix is only allowed once there are at least 3 numeric segments
+// (major.minor.patch): compare-versions' own `validate()`, which compareVersions() below
+// defers to, rejects a suffix on a 1- or 2-segment version (e.g. "0.9-beta"). Accepting that
+// shape here would let it slip past `isExactVersion` at `add` time, then have
+// `compareVersions`/`isDowngrade` silently treat it as unorderable, bypassing the --force
+// gate on a real downgrade.
+const EXACT_VERSION = /^\d+(\.\d+){0,3}$|^\d+(\.\d+){2,3}-[0-9A-Za-z.]+$/;
+export function isExactVersion(value) {
+    return EXACT_VERSION.test(value);
+}
+// -1 / 0 / 1, or null when either side isn't a comparable version (e.g. "latest"). Wraps
+// compare-versions so callers never have to guard against the throw it does on bad input.
+export function compareVersions(a, b) {
+    return validate(a) && validate(b) ? cmp(a, b) : null;
+}