@loopress/cli 0.11.0 → 0.13.0

package/dist/commands/snippet/push.js

@@ -1,18 +1,12 @@
 import { Args } from '@oclif/core';
 import { Listr } from 'listr2';
-import { readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import slugify from 'slugify';
+import { loadSnippets as loadSnippetsFromDisk } from '../../lib/load-snippets.js';
 import { PushCommand } from '../../lib/push-command.js';
 import { isNotFoundError } from '../../lib/wp-client.js';
-import { defaultLocationForType, normalizeSnippet, parseInsertMethod, parseLocation, parseType, SNIPPETS_ENDPOINT, stripPhpOpeningTag, } from '../../utils/snippet-format.js';
-const TYPE_BY_EXTENSION = {
-    '.css': 'css',
-    '.html': 'html',
-    '.js': 'js',
-    '.php': 'php',
-    '.txt': 'text',
-};
+import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../../utils/snippet-format.js';
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
@@ -78,62 +72,12 @@ export default class Push extends PushCommand {
         await rm(oldMetaPath, { force: true });
     }
     async loadSnippets(path) {
-        const snippets = [];
         try {
-            const files = await readdir(path);
-            for (const file of files) {
-                const ext = extname(file);
-                if (!(ext in TYPE_BY_EXTENSION))
-                    continue;
-                const filePath = join(path, file);
-                const metaPath = join(path, `${basename(file, ext)}.json`);
-                const content = await readFile(filePath, 'utf8');
-                let id;
-                let name;
-                let type;
-                let active = false;
-                let tags = [];
-                let location = null;
-                let insertMethod = null;
-                let priority = 10;
-                let shortcodeAttributes = [];
-                try {
-                    const metaContent = await readFile(metaPath, 'utf8');
-                    const meta = JSON.parse(metaContent);
-                    id = meta.id ? Number(meta.id) : undefined;
-                    name = meta.name ? String(meta.name) : undefined;
-                    type = parseType(meta.type) ?? undefined;
-                    active = Boolean(meta.active);
-                    tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
-                    location = parseLocation(meta.location);
-                    insertMethod = parseInsertMethod(meta.insertMethod);
-                    priority = meta.priority === undefined ? 10 : Number(meta.priority);
-                    shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT')
-                        throw error;
-                }
-                const resolvedType = type ?? (ext in TYPE_BY_EXTENSION ? TYPE_BY_EXTENSION[ext] : 'php');
-                snippets.push({
-                    active,
-                    code: content,
-                    id,
-                    insertMethod: insertMethod ?? 'auto',
-                    location: location ?? defaultLocationForType(resolvedType),
-                    name: name ?? basename(file, ext),
-                    path: filePath,
-                    priority,
-                    shortcodeAttributes,
-                    tags,
-                    type: resolvedType,
-                });
-            }
+            return await loadSnippetsFromDisk(path, (message) => this.warn(message));
         }
         catch (error) {
-            this.error(`Error loading snippets: ${error.message}`);
+            this.error(error.message);
         }
-        return snippets;
     }
     // Throwing on failure (rather than returning a boolean) is what lets Listr mark the task as
     // failed (red cross) instead of completed; `exitOnError: false` on the task list still lets

package/dist/config/project-config.manager.d.ts

@@ -4,6 +4,9 @@ export declare class ProjectConfigManager {
     constructor(homeDir?: string);
     createProjectId(name: string): string;
     ensureConfigDir(): void;
+    findProjectByApiId(apiProjectId: string): null | (ProjectConfig & {
+        id: string;
+    });
     getConfigFilePath(): string;
     getCurrentEnv(): EnvironmentConfig | null;
     getCurrentProject(): null | (ProjectConfig & {

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

@@ -25,6 +25,18 @@ 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.
+    findProjectByApiId(apiProjectId) {
+        const config = this.readConfig();
+        for (const [id, project] of Object.entries(config.projects)) {
+            if (project.apiProjectId === apiProjectId)
+                return { ...project, id };
+        }
+        return null;
+    }
     getConfigFilePath() {
         return join(this.homeDir, '.loopress', 'config.json');
     }

package/dist/lib/load-snippets.d.ts

@@ -0,0 +1,2 @@
+import { Snippet } from '../types/snippet.js';
+export declare function loadSnippets(path: string, onSkip?: (message: string) => void): Promise<Snippet[]>;

package/dist/lib/load-snippets.js

@@ -0,0 +1,84 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+import { defaultLocationForType, parseInsertMethod, parseLocation, parseType, } from '../utils/snippet-format.js';
+const TYPE_BY_EXTENSION = {
+    '.css': 'css',
+    '.html': 'html',
+    '.js': 'js',
+    '.php': 'php',
+    '.txt': 'text',
+};
+// Shared by `snippet push` (pushes to the project's own WordPress site) and `snippet publish`
+// (publishes to the Loopress api as a shared source) — both read the same local `snippets/`
+// directory the same way. `onSkip` is optional so callers that don't care about per-file
+// warnings (e.g. `snippet publish`) can ignore them; skipped files are simply left out either way.
+export async function loadSnippets(path, onSkip) {
+    const snippets = [];
+    let files;
+    try {
+        files = await readdir(path);
+    }
+    catch (error) {
+        throw new Error(`Error loading snippets: ${error.message}`);
+    }
+    for (const file of files) {
+        const ext = extname(file);
+        if (!(ext in TYPE_BY_EXTENSION))
+            continue;
+        const filePath = join(path, file);
+        const metaPath = join(path, `${basename(file, ext)}.json`);
+        // One snippet's files are read in isolation: a corrupted or hand-broken sidecar (bad JSON,
+        // unreadable file, ...) must only skip that snippet, not abort loading every other one.
+        let content;
+        try {
+            content = await readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            onSkip?.(`Skipping "${filePath}": ${error.message}`);
+            continue;
+        }
+        let id;
+        let name;
+        let type;
+        let active = false;
+        let tags = [];
+        let location = null;
+        let insertMethod = null;
+        let priority = 10;
+        let shortcodeAttributes = [];
+        try {
+            const metaContent = await readFile(metaPath, 'utf8');
+            const meta = JSON.parse(metaContent);
+            id = meta.id === undefined ? undefined : Number(meta.id);
+            name = meta.name ? String(meta.name) : undefined;
+            type = parseType(meta.type) ?? undefined;
+            active = Boolean(meta.active);
+            tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
+            location = parseLocation(meta.location);
+            insertMethod = parseInsertMethod(meta.insertMethod);
+            priority = meta.priority === undefined ? 10 : Number(meta.priority);
+            shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                onSkip?.(`Skipping "${metaPath}": ${error.message}`);
+                continue;
+            }
+        }
+        const resolvedType = type ?? (ext in TYPE_BY_EXTENSION ? TYPE_BY_EXTENSION[ext] : 'php');
+        snippets.push({
+            active,
+            code: content,
+            id,
+            insertMethod: insertMethod ?? 'auto',
+            location: location ?? defaultLocationForType(resolvedType),
+            name: name ?? basename(file, ext),
+            path: filePath,
+            priority,
+            shortcodeAttributes,
+            tags,
+            type: resolvedType,
+        });
+    }
+    return snippets;
+}

package/dist/lib/local-callback-server.d.ts

@@ -0,0 +1,25 @@
+export type CallbackHelpers<T> = {
+    rejectWithPage: (page: string, error: Error) => void;
+    resolveWithPage: (page: string, value: T) => void;
+    respondBadRequest: (message: string) => void;
+};
+/**
+ * Both `login` and `authorizeWithBrowser` send the user to a URL in their browser and need to
+ * catch the resulting redirect on a short-lived local server; this factors out the server setup,
+ * timeout, and browser-opening boilerplate they'd otherwise duplicate.
+ */
+export declare function waitForLocalCallback<T>(options: {
+    buildUrl: (callbackBaseUrl: string) => string;
+    handleRequest: (url: URL, helpers: CallbackHelpers<T>) => void;
+    log: (message: string) => void;
+    openingMessage: string;
+    timeoutMessage: string;
+    timeoutMs?: number;
+}): Promise<T>;
+export declare function renderResultPage(options: {
+    background: string;
+    heading: string;
+    headingColor: string;
+    icon: string;
+    tabTitle: string;
+}): string;

package/dist/lib/local-callback-server.js

@@ -0,0 +1,93 @@
+import { createServer } from 'node:http';
+import { openBrowser } from './open-browser.js';
+/**
+ * Both `login` and `authorizeWithBrowser` send the user to a URL in their browser and need to
+ * catch the resulting redirect on a short-lived local server; this factors out the server setup,
+ * timeout, and browser-opening boilerplate they'd otherwise duplicate.
+ */
+export function waitForLocalCallback(options) {
+    const timeoutMs = options.timeoutMs ?? 5 * 60 * 1000;
+    return new Promise((resolve, reject) => {
+        function finish(res, page, settle) {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(page);
+            clearTimeout(timer);
+            server.close();
+            settle();
+        }
+        const server = createServer((req, res) => {
+            try {
+                const url = new URL(req.url ?? '/', 'http://localhost');
+                options.handleRequest(url, {
+                    rejectWithPage: (page, error) => finish(res, page, () => reject(error)),
+                    resolveWithPage: (page, value) => finish(res, page, () => resolve(value)),
+                    respondBadRequest(message) {
+                        res.writeHead(400, { 'Content-Type': 'text/plain' });
+                        res.end(message);
+                    },
+                });
+            }
+            catch (error) {
+                res.writeHead(500);
+                res.end('Internal error');
+                server.close();
+                reject(error);
+            }
+        });
+        server.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error(options.timeoutMessage));
+        }, timeoutMs);
+        server.listen(0, '127.0.0.1', () => {
+            const { port } = server.address();
+            const targetUrl = options.buildUrl(`http://localhost:${port}`);
+            options.log(options.openingMessage);
+            options.log(`\nIf it doesn't open automatically, visit:\n${targetUrl}\n`);
+            openBrowser(targetUrl);
+        });
+    });
+}
+export function renderResultPage(options) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Loopress: ${options.tabTitle}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: system-ui, -apple-system, sans-serif;
+      background: ${options.background};
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100dvh;
+    }
+    .card {
+      background: #fff;
+      border-radius: 16px;
+      padding: 2.5rem 3rem;
+      text-align: center;
+      box-shadow: 0 4px 32px rgba(0, 0, 0, .08);
+      max-width: 420px;
+      width: 90%;
+    }
+    .icon { font-size: 3rem; margin-bottom: 1rem; }
+    h1 { color: ${options.headingColor}; font-size: 1.5rem; margin-bottom: .5rem; }
+    p { color: #6b7280; font-size: .95rem; line-height: 1.5; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">${options.icon}</div>
+    <h1>${options.heading}</h1>
+    <p>You can close this tab and return to your terminal.</p>
+  </div>
+</body>
+</html>`;
+}

package/dist/lib/open-browser.d.ts

@@ -0,0 +1,2 @@
+/** Opens `url` in the user's default browser, best-effort (no-op on unknown platforms). */
+export declare function openBrowser(url: string): void;

package/dist/lib/open-browser.js

@@ -0,0 +1,12 @@
+import { execFile } from 'node:child_process';
+/** Opens `url` in the user's default browser, best-effort (no-op on unknown platforms). */
+export function openBrowser(url) {
+    const commands = {
+        darwin: ['open', [url]],
+        linux: ['xdg-open', [url]],
+        win32: ['cmd', ['/c', 'start', '', url]],
+    };
+    const command = commands[process.platform];
+    if (command)
+        execFile(...command);
+}

package/dist/lib/wp-authorize-flow.d.ts

@@ -0,0 +1,10 @@
+export type AuthorizeResult = {
+    password: string;
+    userLogin: string;
+};
+/**
+ * Runs WordPress's native "authorize application" flow: opens a local callback server,
+ * sends the user to `<siteUrl>/wp-admin/authorize-application.php`, and resolves with the
+ * generated Application Password once WordPress redirects back.
+ */
+export declare function authorizeWithBrowser(siteUrl: string, log: (message: string) => void): Promise<AuthorizeResult>;

package/dist/lib/wp-authorize-flow.js

@@ -0,0 +1,53 @@
+import { randomBytes } from 'node:crypto';
+import { renderResultPage, waitForLocalCallback } from './local-callback-server.js';
+const APP_NAME = 'Loopress';
+/**
+ * Runs WordPress's native "authorize application" flow: opens a local callback server,
+ * sends the user to `<siteUrl>/wp-admin/authorize-application.php`, and resolves with the
+ * generated Application Password once WordPress redirects back.
+ */
+export function authorizeWithBrowser(siteUrl, log) {
+    const state = randomBytes(32).toString('hex');
+    return waitForLocalCallback({
+        buildUrl(callbackBaseUrl) {
+            const successUrl = `${callbackBaseUrl}/callback?state=${state}`;
+            const rejectUrl = `${callbackBaseUrl}/reject?state=${state}`;
+            return (`${siteUrl}/wp-admin/authorize-application.php?app_name=${encodeURIComponent(APP_NAME)}` +
+                `&success_url=${encodeURIComponent(successUrl)}&reject_url=${encodeURIComponent(rejectUrl)}`);
+        },
+        handleRequest(url, { rejectWithPage, resolveWithPage, respondBadRequest }) {
+            if (url.searchParams.get('state') !== state) {
+                respondBadRequest('Invalid or missing state');
+                return;
+            }
+            if (url.pathname === '/reject') {
+                rejectWithPage(REJECTED_PAGE, new Error('Authorization rejected in WordPress. You can enter credentials manually instead.'));
+                return;
+            }
+            const userLogin = url.searchParams.get('user_login');
+            const password = url.searchParams.get('password');
+            if (!userLogin || !password) {
+                respondBadRequest('Missing user_login or password');
+                return;
+            }
+            resolveWithPage(SUCCESS_PAGE, { password, userLogin });
+        },
+        log,
+        openingMessage: 'Opening WordPress in your browser to authorize Loopress...',
+        timeoutMessage: 'Authorization timed out after 5 minutes. You can enter credentials manually instead.',
+    });
+}
+const SUCCESS_PAGE = renderResultPage({
+    background: '#f0fdf4',
+    heading: 'Authorization successful!',
+    headingColor: '#15803d',
+    icon: '✅',
+    tabTitle: 'Authorized',
+});
+const REJECTED_PAGE = renderResultPage({
+    background: '#fef2f2',
+    heading: 'Authorization rejected',
+    headingColor: '#b91c1c',
+    icon: '✕',
+    tabTitle: 'Authorization rejected',
+});

package/dist/lib/wp-client.js

@@ -48,10 +48,27 @@ export function formatWpError(error, url) {
         return `Endpoint not found (404) on ${url}. Is the required plugin installed and up to date on the site?`;
     }
     if (status !== undefined) {
-        return `Request failed (${status}) on ${url}.`;
+        const reason = extractServerErrorMessage(err.response?.body);
+        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 to ${url} failed: ${err.message ?? String(error)}`;
 }
+// The Loopress plugin's own controllers reply with `{"error": "..."}`; a WP_Error-based
+// 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.
+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;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/wp-site-diagnostic.d.ts

@@ -0,0 +1,13 @@
+export declare const REQUEST_TIMEOUT_MS = 10000;
+export type DiagnosticResult = {
+    ok: false;
+    reason: string;
+} | {
+    ok: true;
+};
+/**
+ * Pre-flight checks run before starting the browser authorization flow, so failures
+ * (unreachable site, blocked REST API, WordPress too old) surface as an actionable
+ * message instead of a confusing timeout once the browser is already open.
+ */
+export declare function diagnoseWpSite(siteUrl: string): Promise<DiagnosticResult>;

package/dist/lib/wp-site-diagnostic.js

@@ -0,0 +1,46 @@
+import got from 'got';
+export const REQUEST_TIMEOUT_MS = 10_000;
+/**
+ * Pre-flight checks run before starting the browser authorization flow, so failures
+ * (unreachable site, blocked REST API, WordPress too old) surface as an actionable
+ * message instead of a confusing timeout once the browser is already open.
+ */
+export async function diagnoseWpSite(siteUrl) {
+    try {
+        await got.get(`${siteUrl}/wp-json/`, { timeout: { request: REQUEST_TIMEOUT_MS } });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `Could not reach the WordPress REST API at ${siteUrl}/wp-json/. The site may be unreachable, or a security plugin may be blocking it. (${describe(error)})`,
+        };
+    }
+    try {
+        const response = await got.head(`${siteUrl}/wp-admin/authorize-application.php`, {
+            throwHttpErrors: false,
+            timeout: { request: REQUEST_TIMEOUT_MS },
+        });
+        if (response.statusCode === 404) {
+            return {
+                ok: false,
+                reason: `The application authorization page was not found on ${siteUrl}. This WordPress site may be older than 5.6, or the feature may be disabled by a plugin.`,
+            };
+        }
+        if (response.statusCode >= 400) {
+            return {
+                ok: false,
+                reason: `The application authorization page at ${siteUrl}/wp-admin/authorize-application.php returned an error (HTTP ${response.statusCode}).`,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `Could not reach ${siteUrl}/wp-admin/authorize-application.php. (${describe(error)})`,
+        };
+    }
+    return { ok: true };
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}