@loopress/cli 0.18.0 → 0.20.0

package/dist/lib/rotate-app-password.js

@@ -0,0 +1,33 @@
+import { WpClient } from './wp-client.js';
+const APPLICATION_PASSWORDS_PATH = 'wp/v2/users/me/application-passwords';
+export const APP_PASSWORD_MAX_AGE_MS = 90 * 24 * 60 * 60 * 1000;
+export function isAppPasswordStale(addedAt) {
+    return Date.now() - new Date(addedAt).getTime() > APP_PASSWORD_MAX_AGE_MS;
+}
+// Create the new credential, confirm it actually authenticates on its own, only then revoke
+// the old one. Reversing this order risks locking the user out if the new one is somehow bad.
+export async function rotateAppPassword(env) {
+    const [user] = env.token.split(':');
+    const oldClient = new WpClient(env.url, env.token);
+    const old = await oldClient.get(`${APPLICATION_PASSWORDS_PATH}/introspect`);
+    const created = await oldClient.post(APPLICATION_PASSWORDS_PATH, { name: 'Loopress' });
+    if (!created.password) {
+        throw new Error(`WordPress did not return a password when creating the new application password on ${env.url}.`);
+    }
+    const newToken = `${user}:${created.password}`;
+    const newClient = new WpClient(env.url, newToken);
+    try {
+        await newClient.get(`${APPLICATION_PASSWORDS_PATH}/introspect`);
+    }
+    catch (error) {
+        // The new credential exists on WordPress but was never confirmed to work: clean it up with
+        // the still-valid old credentials instead of leaving an orphan behind. maybeAutoRotate
+        // retries on every subsequent run, so a persistent failure here would otherwise pile up
+        // one abandoned 'Loopress' entry per attempt. Best-effort: a failure here shouldn't hide
+        // the original, more informative error.
+        await oldClient.delete(`${APPLICATION_PASSWORDS_PATH}/${created.uuid}`).catch(() => { });
+        throw error;
+    }
+    await newClient.delete(`${APPLICATION_PASSWORDS_PATH}/${old.uuid}`);
+    return { ...env, addedAt: new Date().toISOString(), token: newToken };
+}

package/dist/lib/temp-admin.d.ts

@@ -0,0 +1,19 @@
+import { WpClient } from './wp-client.js';
+export interface TempAdmin {
+    id: number;
+    password: string;
+    username: string;
+}
+/**
+ * Creates a temporary WordPress administrator, the only way to obtain `install_plugins` when
+ * all the CLI has is an application password. `.invalid` is the RFC 2606 reserved TLD for
+ * addresses guaranteed not to be real, appropriate for an account that has no real mailbox.
+ */
+export declare function createTempAdmin(wp: WpClient): Promise<TempAdmin>;
+/**
+ * Deletes the temporary admin, reassigning any content it might own to the real user behind
+ * the app password. Failure here throws rather than warns, naming the leftover account: a
+ * cleanup that silently fails would leave a live administrator with a random password on the
+ * target site, discoverable only by someone reading logs closely.
+ */
+export declare function deleteTempAdmin(wp: WpClient, admin: TempAdmin): Promise<void>;

package/dist/lib/temp-admin.js

@@ -0,0 +1,46 @@
+import { randomBytes } from 'node:crypto';
+import { isNotFoundError } from './wp-client.js';
+// Only role that carries `install_plugins`/`activate_plugins`; there's nothing narrower to grant.
+const TEMP_ADMIN_ROLE = 'administrator';
+/**
+ * Creates a temporary WordPress administrator, the only way to obtain `install_plugins` when
+ * all the CLI has is an application password. `.invalid` is the RFC 2606 reserved TLD for
+ * addresses guaranteed not to be real, appropriate for an account that has no real mailbox.
+ */
+export async function createTempAdmin(wp) {
+    const username = `lps-temp-${Date.now().toString(36)}`;
+    const password = randomBytes(24).toString('base64url');
+    const user = await wp.post('wp/v2/users', {
+        email: `${username}@lps-temp.invalid`,
+        password,
+        roles: [TEMP_ADMIN_ROLE],
+        username,
+    });
+    return { id: user.id, password, username };
+}
+/**
+ * Deletes the temporary admin, reassigning any content it might own to the real user behind
+ * the app password. Failure here throws rather than warns, naming the leftover account: a
+ * cleanup that silently fails would leave a live administrator with a random password on the
+ * target site, discoverable only by someone reading logs closely.
+ */
+export async function deleteTempAdmin(wp, admin) {
+    const me = await wp.get('wp/v2/users/me');
+    try {
+        await wp.delete(`wp/v2/users/${admin.id}?reassign=${me.id}&force=true`);
+    }
+    catch (error) {
+        throw new Error(`Failed to remove the temporary admin account "${admin.username}" (id ${admin.id}) from the site. Remove it manually from wp-admin.`, { cause: error });
+    }
+    const stillExists = await wp
+        .get(`wp/v2/users/${admin.id}`)
+        .then(() => true)
+        .catch((error) => {
+        if (isNotFoundError(error))
+            return false;
+        throw error;
+    });
+    if (stillExists) {
+        throw new Error(`Temporary admin account "${admin.username}" (id ${admin.id}) still exists after deletion. Remove it manually from wp-admin.`);
+    }
+}

package/dist/lib/wp-client.d.ts

@@ -7,10 +7,16 @@ export declare class WpClient {
     private readonly siteUrl;
     private readonly client;
     constructor(siteUrl: string, token: string);
-    get<T>(path: string): Promise<T>;
-    post<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;
-    put<T = unknown>(path: string, json?: Record<string, unknown>): Promise<T>;
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    put<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
     private request;
 }
+interface RequestOptions {
+    timeoutMs?: number;
+}
 export declare function isNotFoundError(error: unknown): boolean;
-export declare function formatWpError(error: unknown, url: string): string;
+export declare function isTimeoutError(error: unknown): boolean;
+export declare function formatWpError(error: unknown, url: string, timeoutMs?: number): string;
+export {};

package/dist/lib/wp-client.js

@@ -15,22 +15,26 @@ export class WpClient {
             timeout: { request: REQUEST_TIMEOUT_MS },
         });
     }
-    async get(path) {
-        return this.request('get', path);
+    async delete(path, options) {
+        return this.request('delete', path, undefined, options);
     }
-    async post(path, json) {
-        return this.request('post', path, json);
+    async get(path, options) {
+        return this.request('get', path, undefined, options);
     }
-    async put(path, json) {
-        return this.request('put', path, json);
+    async post(path, json, options) {
+        return this.request('post', path, json, options);
     }
-    async request(method, path, json) {
+    async put(path, json, options) {
+        return this.request('put', path, json, options);
+    }
+    async request(method, path, json, options) {
+        const timeoutMs = options?.timeoutMs ?? REQUEST_TIMEOUT_MS;
         try {
-            const response = await this.client(path, { json, method });
+            const response = await this.client(path, { json, method, timeout: { request: timeoutMs } });
             return (response.body ? JSON.parse(response.body) : undefined);
         }
         catch (error) {
-            throw new Error(formatWpError(error, `${this.siteUrl}/wp-json/${path}`), { cause: error });
+            throw new Error(formatWpError(error, `${this.siteUrl}/wp-json/${path}`, timeoutMs), { cause: error });
         }
     }
 }
@@ -38,7 +42,11 @@ export function isNotFoundError(error) {
     const cause = error?.cause;
     return cause?.response?.statusCode === 404;
 }
-export function formatWpError(error, url) {
+export function isTimeoutError(error) {
+    const cause = error?.cause;
+    return cause?.name === 'TimeoutError';
+}
+export function formatWpError(error, url, timeoutMs = REQUEST_TIMEOUT_MS) {
     const err = error;
     const status = err.response?.statusCode;
     if (status === 401 || status === 403) {
@@ -52,7 +60,7 @@ export function formatWpError(error, url) {
         return reason ? `Request failed (${status}) on ${url}: ${reason}` : `Request failed (${status}) on ${url}.`;
     }
     if (err.name === 'TimeoutError') {
-        return `Request timed out after ${REQUEST_TIMEOUT_MS / 1000}s on ${url}. Is the site reachable?`;
+        return `Request timed out after ${timeoutMs / 1000}s on ${url}. Is the site reachable?`;
     }
     return `Request to ${url} failed: ${err.message ?? String(error)}`;
 }
@@ -60,13 +68,22 @@ export function formatWpError(error, url) {
 // core response (e.g. an uncaught fatal formatted by WordPress itself) uses `{"message": "..."}`.
 // Surfacing this is what makes a deliberately clear server-side error (e.g. "Multiple snippet
 // plugins are active...") actually reach the user instead of a bare, unhelpful status code.
+//
+// Some controllers (ComposerController::sync(), notably) pair a short, generic `error` (e.g.
+// "Sync failed.") with the real detail in a separate `output` field (the raw Composer trace),
+// specifically so a caller that only reads `error` doesn't see it — which is exactly what this
+// function used to do, hiding the one piece of text that actually explains the failure.
 function extractServerErrorMessage(body) {
     if (!body)
         return undefined;
     try {
         const parsed = JSON.parse(body);
         const reason = parsed.error ?? parsed.message;
-        return typeof reason === 'string' && reason.trim() ? reason : undefined;
+        const summary = typeof reason === 'string' && reason.trim() ? reason : undefined;
+        const detail = typeof parsed.output === 'string' && parsed.output.trim() ? parsed.output.trim() : undefined;
+        if (summary && detail)
+            return `${summary}\n${detail}`;
+        return summary ?? detail;
     }
     catch {
         return undefined;

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

@@ -23,6 +23,10 @@ export interface LoopressProjectConfiguration {
      * Directory where forms (WPForms today) are read from and written to, relative to rootDir.
      */
     formDir?: string;
+    /**
+     * Directory where WordPress pages are read from and written to, relative to rootDir.
+     */
+    pageDir?: string;
     /**
      * Directory where custom API route files are read from and written to, relative to rootDir.
      */

package/dist/utils/composer.d.ts

@@ -1,4 +1,7 @@
 export interface ComposerJson {
+    config?: {
+        'allow-plugins'?: Record<string, boolean>;
+    };
     extra?: {
         'installer-paths'?: Record<string, string[]>;
     };

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

@@ -0,0 +1,7 @@
+export declare const PAGE_ENDPOINT = "wp/v2/pages";
+export declare const PAGE_LIST_QUERY = "per_page=100";
+export declare function getPageId(data: Record<string, unknown>): null | number;
+export declare function getPageTitle(data: Record<string, unknown>): string;
+export declare function pageFileBase(id: number, title: string): string;
+export declare function pickPageMeta(data: Record<string, unknown>): Record<string, unknown>;
+export declare function getPageContent(data: Record<string, unknown>): string;

package/dist/utils/page-format.js

@@ -0,0 +1,78 @@
+import { toSlug } from './to-slug.js';
+// WordPress core's own REST endpoint (`wp/v2/pages`), unlike acf/form/seo/snippet there is no
+// Loopress-plugin controller behind this one, same principle as `wp/v2/plugins` in plugin push/pull.
+export const PAGE_ENDPOINT = 'wp/v2/pages';
+// ponytail: fixed cap, not a paged loop; fine for typical page counts, revisit with real
+// pagination (X-WP-TotalPages) if a site ever has more than 100 pages.
+export const PAGE_LIST_QUERY = 'per_page=100';
+export function getPageId(data) {
+    const id = Number(data.id);
+    return Number.isInteger(id) && id > 0 ? id : null;
+}
+// `title`/`content`/`excerpt` come back as `{raw, rendered}` from `?context=edit` (what `page
+// pull` requests) but round-trip fine as plain strings too for a hand-created file, same
+// looseness as getFormTitle in form-format.ts.
+export function getPageTitle(data) {
+    const { title } = data;
+    if (typeof title === 'string' && title.trim() !== '')
+        return title;
+    if (title && typeof title === 'object') {
+        const { raw, rendered } = title;
+        if (typeof raw === 'string' && raw.trim() !== '')
+            return raw;
+        if (typeof rendered === 'string' && rendered.trim() !== '')
+            return rendered;
+    }
+    return '(untitled)';
+}
+export function pageFileBase(id, title) {
+    return `${id}-${toSlug(title, 'untitled')}`;
+}
+// The fields WordPress core actually accepts on write to `wp/v2/pages` (confirmed via
+// `OPTIONS wp/v2/pages`), plus `id` for local identity. A GET response carries a lot more:
+// `guid`, `link`, `modified`/`modified_gmt`, `permalink_template`, `generated_slug`,
+// `class_list`, `type`, `_links`, all of it readonly/computed by WordPress, most of it
+// domain- or revision-specific. `_links` alone is the bulk of the file and, like
+// `modified`/`modified_gmt`, changes on every edit regardless of whether the page's actual
+// content changed, which would make every `page pull` produce a spurious git diff if kept.
+const PAGE_META_FIELDS = [
+    'id',
+    'date',
+    'date_gmt',
+    'slug',
+    'status',
+    'password',
+    'parent',
+    'title',
+    'author',
+    'excerpt',
+    'featured_media',
+    'comment_status',
+    'ping_status',
+    'menu_order',
+    'meta',
+    'template',
+];
+export function pickPageMeta(data) {
+    const meta = {};
+    for (const field of PAGE_META_FIELDS) {
+        if (field in data)
+            meta[field] = data[field];
+    }
+    return meta;
+}
+// `content` comes back as `{raw, rendered}` from `?context=edit` (what `page pull` requests);
+// a hand-created file only has the plain string. This is the one field split out into its own
+// `.html` file by pull/push: raw Gutenberg block markup escaped inside a JSON string is neither
+// readable nor safely hand-editable, same reasoning as the code/meta split in snippet-format.ts.
+export function getPageContent(data) {
+    const { content } = data;
+    if (typeof content === 'string')
+        return content;
+    if (content && typeof content === 'object') {
+        const { raw } = content;
+        if (typeof raw === 'string')
+            return raw;
+    }
+    return '';
+}

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

@@ -18,3 +18,4 @@ export interface SeoRedirect {
     updatedAt: null | string;
     urlTo: string;
 }
+export declare function redirectFileBase(redirect: SeoRedirect): string;

package/dist/utils/seo-format.js

@@ -1,3 +1,4 @@
+import { toSlug } from './to-slug.js';
 // Post types synced by `lps seo pull` when --post-type isn't given.
 export const DEFAULT_POST_TYPES = ['post', 'page'];
 export const SEO_SETTINGS_ENDPOINT = 'loopress/v1/seo/settings';
@@ -8,3 +9,7 @@ export function seoRedirectEndpoint(id) {
 export function seoPostMetaEndpoint(postType) {
     return `loopress/v1/seo/post-meta/${postType}`;
 }
+// The `<id>-<slug>.json` on-disk convention shared by `seo pull` and `seo push`.
+export function redirectFileBase(redirect) {
+    return `${redirect.id}-${toSlug(redirect.urlTo, 'redirect')}`;
+}

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

@@ -20,4 +20,6 @@ export declare function parseLocation(raw: unknown): null | SnippetLocation;
 export declare function parseInsertMethod(raw: unknown): null | SnippetInsertMethod;
 export declare function defaultLocationForType(type: SnippetType): SnippetLocation;
 export declare function stripPhpOpeningTag(code: string): string;
+export declare function buildSnippetFile(snippet: NormalizedSnippet): string;
+export declare function buildMetaFile(snippet: NormalizedSnippet): string;
 export declare function normalizeSnippet(data: Record<string, unknown>): NormalizedSnippet;

package/dist/utils/snippet-format.js

@@ -34,10 +34,36 @@ function resolvePriority(raw) {
 }
 // Snippet files on disk keep the <?php opening tag so they're valid, syntax-highlighted PHP files.
 // The WordPress plugin stores just the executable body, so it's stripped before push and restored
-// on pull (see buildSnippetFile in commands/snippet/pull.ts).
+// on pull (see buildSnippetFile below).
 export function stripPhpOpeningTag(code) {
     return code.replace(/^<\?php\s*/i, '');
 }
+export function buildSnippetFile(snippet) {
+    if (snippet.type === 'php' && !snippet.code.trimStart().startsWith('<?')) {
+        return `<?php\n\n${snippet.code}`;
+    }
+    return snippet.code;
+}
+export function buildMetaFile(snippet) {
+    const meta = {
+        id: snippet.id,
+        name: snippet.name,
+        type: snippet.type,
+        active: snippet.active,
+        location: snippet.location,
+    };
+    if (snippet.description)
+        meta.description = snippet.description;
+    if (snippet.tags.length > 0)
+        meta.tags = snippet.tags;
+    if (snippet.insertMethod === 'shortcode')
+        meta.insertMethod = snippet.insertMethod;
+    if (snippet.priority !== 10)
+        meta.priority = snippet.priority;
+    if (snippet.shortcodeAttributes.length > 0)
+        meta.shortcodeAttributes = snippet.shortcodeAttributes;
+    return JSON.stringify(meta, null, 2) + '\n';
+}
 // Defensive coercion for whatever JSON the `loopress/v1/snippets` endpoint returns, in case a
 // field is missing or malformed server-side.
 export function normalizeSnippet(data) {

package/dist/utils/to-slug.d.ts

@@ -0,0 +1 @@
+export declare function toSlug(value: string, fallback?: string): string;

package/dist/utils/to-slug.js

@@ -0,0 +1,7 @@
+import slugify from 'slugify';
+// The one slugification used everywhere a name becomes part of a filename or an api slug.
+// `fallback` covers values that slugify to nothing (empty, punctuation-only); callers that
+// can genuinely live with an empty slug just omit it.
+export function toSlug(value, fallback = '') {
+    return slugify(value, { lower: true, strict: true }) || fallback;
+}