@loopress/cli 0.18.0 → 0.19.0

package/dist/lib/wp-client.js

@@ -15,22 +15,23 @@ export class WpClient {
             timeout: { request: REQUEST_TIMEOUT_MS },
         });
     }
-    async get(path) {
-        return this.request('get', path);
+    async get(path, options) {
+        return this.request('get', path, undefined, options);
     }
-    async post(path, json) {
-        return this.request('post', path, json);
+    async post(path, json, options) {
+        return this.request('post', path, json, options);
     }
-    async put(path, json) {
-        return this.request('put', path, json);
+    async put(path, json, options) {
+        return this.request('put', path, json, options);
     }
-    async request(method, path, json) {
+    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 +39,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 +57,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 +65,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/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/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;
+}