@loopress/cli 0.7.0 → 0.8.0

package/dist/lib/base.js

@@ -2,70 +2,100 @@ import { Command, Flags } from '@oclif/core';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
+import { WpClient } from './wp-client.js';
 export class LoopressCommand extends Command {
     static baseFlags = {
         password: Flags.string({
-            description: 'WordPress application password (fallback; prefer `lps project config`)',
+            description: 'WordPress application password (overrides project config, requires --user)',
             helpGroup: 'GLOBAL',
         }),
         url: Flags.string({
-            description: 'WordPress URL (fallback; prefer `lps project config`)',
+            description: 'WordPress URL (overrides project config)',
             helpGroup: 'GLOBAL',
         }),
         user: Flags.string({
-            description: 'WordPress username (fallback; prefer `lps project config`)',
+            description: 'WordPress username (overrides project config, requires --password)',
             helpGroup: 'GLOBAL',
         }),
     };
+    static dryRunFlag = {
+        'dry-run': Flags.boolean({ char: 'd', description: 'Show what would change without making changes' }),
+    };
+    dryRun = false;
+    localConfig = {};
     siteConfig;
-    async buildAuthHeaders() {
-        const { token, url } = this.siteConfig;
-        if (token) {
-            return { Authorization: `Basic ${Buffer.from(token).toString('base64')}` };
+    wpClient;
+    get rootDir() {
+        return this.localConfig.rootDir ?? '.';
+    }
+    get wp() {
+        if (!this.wpClient) {
+            const { token, url } = this.siteConfig;
+            if (!token) {
+                this.error(`No credentials configured for ${url}. Run \`lps project config\` to add them.`);
+            }
+            this.wpClient = new WpClient(url, token);
         }
-        this.error(`No credentials configured for ${url}. Run \`lps project config\` to add them.`);
+        return this.wpClient;
     }
     async init() {
         await super.init();
-        const localConfig = await readLocalConfig();
-        if (localConfig.projectId) {
-            const project = configManager.getProject(localConfig.projectId);
+        const { flags } = (await this.parse({
+            args: this.ctor.args,
+            flags: this.ctor.flags,
+            strict: this.ctor.strict,
+        }));
+        this.dryRun = Boolean(flags['dry-run']);
+        this.localConfig = await readLocalConfig();
+        if (Boolean(flags.user) !== Boolean(flags.password)) {
+            this.error('--user and --password must be provided together.');
+        }
+        const flagToken = flags.user && flags.password ? `${flags.user}:${flags.password}` : undefined;
+        if (flags.url) {
+            this.siteConfig = {
+                addedAt: new Date().toISOString(),
+                name: 'cli-flags',
+                token: flagToken,
+                url: flags.url.replace(/\/+$/, ''),
+            };
+            return;
+        }
+        const env = this.resolveEnvironment();
+        this.siteConfig = flagToken ? { ...env, token: flagToken } : env;
+    }
+    resolveSnippetPlugin(flag) {
+        if (flag)
+            return flag;
+        return this.localConfig.snippetPlugin ?? 'wpcode';
+    }
+    resolveSnippetsPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.snippetsDir ?? 'snippets');
+    }
+    resolveEnvironment() {
+        if (this.localConfig.projectId) {
+            const project = configManager.getProject(this.localConfig.projectId);
             if (!project) {
-                this.error(`Project "${localConfig.projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
+                this.error(`Project "${this.localConfig.projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
             }
             const envNames = Object.keys(project.environments);
             if (envNames.length === 0) {
                 this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
             }
             if (envNames.length === 1) {
-                this.siteConfig = project.environments[envNames[0]];
-                return;
+                return project.environments[envNames[0]];
             }
             const current = configManager.getCurrentProject();
-            const currentEnv = current?.id === localConfig.projectId ? configManager.getCurrentEnv() : null;
+            const currentEnv = current?.id === this.localConfig.projectId ? configManager.getCurrentEnv() : null;
             if (!currentEnv) {
                 this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
             }
-            this.siteConfig = currentEnv;
-            return;
+            return currentEnv;
         }
         const env = configManager.getCurrentEnv();
-        if (env) {
-            this.siteConfig = env;
-            return;
-        }
+        if (env)
+            return env;
         this.error('No environment configured. Run `lps project config` first.');
     }
-    async resolveSnippetPlugin(flag) {
-        if (flag)
-            return flag;
-        const config = await readLocalConfig();
-        return config.snippetPlugin ?? 'wpcode';
-    }
-    async resolveSnippetsPath(override) {
-        if (override)
-            return override;
-        const config = await readLocalConfig();
-        return join(config.rootDir ?? '.', config.snippetsDir ?? 'snippets');
-    }
 }

package/dist/lib/push-command.d.ts

@@ -1,6 +1,5 @@
 import { LoopressCommand } from './base.js';
 export declare abstract class PushCommand extends LoopressCommand {
-    protected dryRun: boolean;
     catch(err: Error): Promise<void>;
     protected recordDeployment(status: 'failure' | 'success'): Promise<void>;
     protected recordSuccess(): Promise<void>;

package/dist/lib/push-command.js

@@ -3,7 +3,6 @@ import { authManager } from '../config/auth.manager.js';
 import { LoopressCommand } from './base.js';
 const API_URL = process.env.LPS_API_URL ?? 'https://api.loopress.dev';
 export class PushCommand extends LoopressCommand {
-    dryRun = false;
     async catch(err) {
         if (!this.dryRun && this.siteConfig) {
             await this.recordDeployment('failure');

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

@@ -0,0 +1,15 @@
+export declare const REQUEST_TIMEOUT_MS = 30000;
+/**
+ * HTTP client for a WordPress site's REST API.
+ * Paths are relative to `<site>/wp-json/`, e.g. `loopress/v1/plugins`.
+ */
+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>;
+    private request;
+}
+export declare function formatWpError(error: unknown, url: string): string;

package/dist/lib/wp-client.js

@@ -0,0 +1,53 @@
+import got from 'got';
+export const REQUEST_TIMEOUT_MS = 30_000;
+/**
+ * HTTP client for a WordPress site's REST API.
+ * Paths are relative to `<site>/wp-json/`, e.g. `loopress/v1/plugins`.
+ */
+export class WpClient {
+    siteUrl;
+    client;
+    constructor(siteUrl, token) {
+        this.siteUrl = siteUrl;
+        this.client = got.extend({
+            headers: { Authorization: `Basic ${Buffer.from(token).toString('base64')}` },
+            prefixUrl: `${siteUrl}/wp-json`,
+            timeout: { request: REQUEST_TIMEOUT_MS },
+        });
+    }
+    async get(path) {
+        return this.request('get', path);
+    }
+    async post(path, json) {
+        return this.request('post', path, json);
+    }
+    async put(path, json) {
+        return this.request('put', path, json);
+    }
+    async request(method, path, json) {
+        try {
+            const response = await this.client(path, { json, method });
+            return (response.body ? JSON.parse(response.body) : undefined);
+        }
+        catch (error) {
+            throw new Error(formatWpError(error, `${this.siteUrl}/wp-json/${path}`), { cause: error });
+        }
+    }
+}
+export function formatWpError(error, url) {
+    const err = error;
+    const status = err.response?.statusCode;
+    if (status === 401 || status === 403) {
+        return `Authentication failed (${status}) on ${url}. Check your credentials with \`lps project config\`.`;
+    }
+    if (status === 404) {
+        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}.`;
+    }
+    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)}`;
+}

package/dist/types/snippet.d.ts

@@ -1,8 +1,14 @@
-import { SnippetType } from '../utils/snippet-plugin.js';
+import { SnippetInsertMethod, SnippetLocation, SnippetType } from '../utils/snippet-plugin.js';
 export interface Snippet {
+    active: boolean;
     code: string;
     id?: number;
+    insertMethod: SnippetInsertMethod;
+    location: SnippetLocation;
     name: string;
     path: string;
+    priority: number;
+    shortcodeAttributes: string[];
+    tags: string[];
     type: SnippetType;
 }

package/dist/utils/loopress-config.js

@@ -1,16 +1,19 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+// Only a missing file is treated as "no config" (returns {}). A file that exists but
+// fails to read or parse throws, so callers don't silently fall back to the global
+// current environment when loopress.json is actually broken.
 export async function readLocalConfig() {
     const configPath = join(process.cwd(), 'loopress.json');
     if (!existsSync(configPath))
         return {};
+    const content = await readFile(configPath, 'utf8');
     try {
-        const content = await readFile(configPath, 'utf8');
         return JSON.parse(content);
     }
     catch {
-        return {};
+        throw new Error('loopress.json is not valid JSON. Fix or delete it, then run `lps init` again.');
     }
 }
 export async function writeLocalConfig(config) {

package/dist/utils/snippet-plugin-flag.d.ts

@@ -0,0 +1,3 @@
+export declare const snippetPluginFlag: {
+    plugin: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+};

package/dist/utils/snippet-plugin-flag.js

@@ -0,0 +1,8 @@
+import { Flags } from '@oclif/core';
+export const snippetPluginFlag = {
+    plugin: Flags.string({
+        char: 'p',
+        description: 'WordPress snippet plugin to target (overrides loopress.json)',
+        options: ['code-snippets', 'wpcode'],
+    }),
+};

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

@@ -1,18 +1,39 @@
 export type PluginName = 'code-snippets' | 'wpcode';
 export type SnippetType = 'css' | 'html' | 'js' | 'php' | 'text';
+export type SnippetInsertMethod = 'auto' | 'shortcode';
+export type SnippetLocation = 'admin' | 'body' | 'everywhere' | 'footer' | 'frontend' | 'header' | 'once';
 export interface NormalizedSnippet {
     active: boolean;
     code: string;
     description: string;
     id: number;
+    insertMethod: SnippetInsertMethod;
+    location: SnippetLocation;
     name: string;
+    priority: number;
+    shortcodeAttributes: string[];
     tags: string[];
     type: SnippetType;
 }
 export declare function parseType(raw: unknown): null | SnippetType;
+export declare function parseLocation(raw: unknown): null | SnippetLocation;
+export declare function parseInsertMethod(raw: unknown): null | SnippetInsertMethod;
+export declare function defaultLocationForType(type: SnippetType): SnippetLocation;
+export interface SnippetPayloadInput {
+    active: boolean;
+    code: string;
+    insertMethod: SnippetInsertMethod;
+    location: SnippetLocation;
+    name: string;
+    path: string;
+    priority: number;
+    shortcodeAttributes: string[];
+    tags: string[];
+    type: SnippetType;
+}
 export interface SnippetPlugin {
-    endpoint(siteUrl: string): string;
+    endpointPath(): string;
     fromRemote(data: Record<string, unknown>): NormalizedSnippet;
-    toPayload(name: string, code: string, path: string, type: SnippetType): Record<string, unknown>;
+    toPayload(snippet: SnippetPayloadInput): Record<string, unknown>;
 }
 export declare function getSnippetPlugin(name: PluginName): SnippetPlugin;

package/dist/utils/snippet-plugin.js

@@ -3,6 +3,30 @@ export function parseType(raw) {
     const value = String(raw ?? '').toLowerCase();
     return valid.includes(value) ? value : null;
 }
+const VALID_LOCATIONS = new Set(['admin', 'body', 'everywhere', 'footer', 'frontend', 'header', 'once']);
+export function parseLocation(raw) {
+    const value = String(raw ?? '').toLowerCase();
+    return VALID_LOCATIONS.has(value) ? value : null;
+}
+export function parseInsertMethod(raw) {
+    return raw === 'auto' || raw === 'shortcode' ? raw : null;
+}
+// The sensible default placement for a freshly pushed snippet that doesn't specify a location.
+export function defaultLocationForType(type) {
+    switch (type) {
+        case 'css': {
+            return 'header';
+        }
+        case 'html':
+        case 'js':
+        case 'text': {
+            return 'footer';
+        }
+        case 'php': {
+            return 'everywhere';
+        }
+    }
+}
 function inferTypeFromCode(code) {
     const firstLine = code.trimStart().split('\n')[0].trimStart();
     if (firstLine.startsWith('<?'))
@@ -14,53 +38,184 @@ function inferTypeFromCode(code) {
 function resolveType(raw, code) {
     return parseType(raw) ?? inferTypeFromCode(code);
 }
+function resolvePriority(raw) {
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : 10;
+}
+// Snippet files on disk keep the <?php opening tag so they're valid, syntax-highlighted PHP files.
+// Both plugins store just the executable body, so it's stripped before push and restored on pull
+// (see buildSnippetFile in commands/snippet/pull.ts).
+function stripPhpOpeningTag(code) {
+    return code.replace(/^<\?php\s*/i, '');
+}
+// The real Code Snippets plugin has no independent "type" field: its REST API only has `scope`,
+// and the snippet type is derived from it (see WPCode_Snippet::get_type_from_scope() upstream).
+// Sending a `type` key (as this adapter used to) is silently ignored by that plugin.
+const CODE_SNIPPETS_SCOPE_TO_LOCATION = {
+    admin: 'admin',
+    'admin-css': 'admin',
+    content: 'everywhere',
+    'footer-content': 'footer',
+    'front-end': 'frontend',
+    global: 'everywhere',
+    'head-content': 'header',
+    'single-use': 'once',
+    'site-css': 'frontend',
+    'site-footer-js': 'footer',
+    'site-head-js': 'header',
+};
+function typeFromScope(scope) {
+    if (scope.endsWith('-css'))
+        return 'css';
+    if (scope.endsWith('-js'))
+        return 'js';
+    if (scope.endsWith('content'))
+        return 'html';
+    return 'php';
+}
+function scopeFromTypeAndLocation(type, location) {
+    switch (type) {
+        case 'css': {
+            if (location === 'frontend')
+                return 'site-css';
+            if (location === 'admin')
+                return 'admin-css';
+            throw new Error(`Code Snippets does not support the "${location}" location for CSS snippets. Use one of: frontend, admin.`);
+        }
+        case 'html': {
+            if (location === 'header')
+                return 'head-content';
+            if (location === 'footer')
+                return 'footer-content';
+            if (location === 'everywhere')
+                return 'content';
+            throw new Error(`Code Snippets does not support the "${location}" location for HTML snippets. Use one of: header, footer, everywhere.`);
+        }
+        case 'js': {
+            if (location === 'header')
+                return 'site-head-js';
+            if (location === 'footer')
+                return 'site-footer-js';
+            throw new Error(`Code Snippets does not support the "${location}" location for JS snippets. Use one of: header, footer.`);
+        }
+        case 'php': {
+            if (location === 'everywhere')
+                return 'global';
+            if (location === 'frontend')
+                return 'front-end';
+            if (location === 'admin')
+                return 'admin';
+            if (location === 'once')
+                return 'single-use';
+            throw new Error(`Code Snippets does not support the "${location}" location for PHP snippets. Use one of: everywhere, frontend, admin, once.`);
+        }
+        case 'text': {
+            throw new Error('Code Snippets has no "text" snippet type. Change the sidecar "type", or push this snippet to "wpcode" instead.');
+        }
+    }
+}
 class CodeSnippetsPlugin {
-    endpoint(siteUrl) {
-        return `${siteUrl}/wp-json/code-snippets/v1/snippets`;
+    endpointPath() {
+        return 'code-snippets/v1/snippets';
     }
     fromRemote(data) {
+        const scope = String(data.scope ?? 'global');
+        const type = typeFromScope(scope);
         return {
             active: Boolean(data.active),
             code: String(data.code ?? ''),
             description: String(data.desc ?? ''),
             id: Number(data.id),
+            insertMethod: 'auto',
+            location: CODE_SNIPPETS_SCOPE_TO_LOCATION[scope] ?? defaultLocationForType(type),
             name: String(data.name ?? ''),
+            priority: resolvePriority(data.priority),
+            shortcodeAttributes: [],
             tags: Array.isArray(data.tags) ? data.tags : [],
-            type: resolveType(data.type, String(data.code ?? '')),
+            type,
         };
     }
-    toPayload(name, code, path, type) {
+    toPayload({ active, code, location, name, path, priority, tags, type }) {
         return {
-            code: code.replace(/^<\?php\s*/i, ''),
+            active,
+            code: stripPhpOpeningTag(code),
             desc: `Imported from ${path}`,
             name,
-            tags: ['cli-import'],
-            type,
+            priority,
+            scope: scopeFromTypeAndLocation(type, location),
+            tags,
         };
     }
 }
+// WPCode taxonomy term slugs (see wpcode_register_taxonomies() and the auto-insert location
+// classes upstream). 'everywhere' | 'frontend_only' | 'admin_only' | 'on_demand' only apply to
+// PHP snippets; 'site_wide_header' | 'site_wide_body' | 'site_wide_footer' apply to any type.
+const WPCODE_PHP_ONLY_LOCATIONS = {
+    admin: 'admin_only',
+    everywhere: 'everywhere',
+    frontend: 'frontend_only',
+    once: 'on_demand',
+};
+const WPCODE_UNIVERSAL_LOCATIONS = {
+    body: 'site_wide_body',
+    footer: 'site_wide_footer',
+    header: 'site_wide_header',
+};
+const WPCODE_LOCATION_TO_CANONICAL = {
+    'admin_only': 'admin',
+    everywhere: 'everywhere',
+    'frontend_only': 'frontend',
+    'on_demand': 'once',
+    'site_wide_body': 'body',
+    'site_wide_footer': 'footer',
+    'site_wide_header': 'header',
+};
+function wpcodeLocationTerm(type, location) {
+    const universal = WPCODE_UNIVERSAL_LOCATIONS[location];
+    if (universal)
+        return universal;
+    if (type === 'php') {
+        const phpOnly = WPCODE_PHP_ONLY_LOCATIONS[location];
+        if (phpOnly)
+            return phpOnly;
+    }
+    const allowed = type === 'php' ? 'header, body, footer, everywhere, frontend, admin, once' : 'header, body, footer';
+    throw new Error(`WPCode does not support the "${location}" location for ${type} snippets. Use one of: ${allowed}.`);
+}
 class WPCodePlugin {
-    endpoint(siteUrl) {
-        return `${siteUrl}/wp-json/loopress/v1/wpcode/snippets`;
+    endpointPath() {
+        return 'loopress/v1/wpcode/snippets';
     }
     fromRemote(data) {
+        const type = resolveType(data.type, String(data.code ?? ''));
         return {
             active: Boolean(data.active),
             code: String(data.code ?? ''),
             description: String(data.note ?? ''),
             id: Number(data.id),
+            insertMethod: data.insert_method === 'shortcode' ? 'shortcode' : 'auto',
+            location: WPCODE_LOCATION_TO_CANONICAL[String(data.location)] ?? defaultLocationForType(type),
             name: String(data.title ?? ''),
+            priority: resolvePriority(data.priority),
+            shortcodeAttributes: Array.isArray(data.shortcode_attributes) ? data.shortcode_attributes.map(String) : [],
             tags: Array.isArray(data.tags) ? data.tags : [],
-            type: resolveType(data.type, String(data.code ?? '')),
+            type,
         };
     }
-    toPayload(name, code, path, type) {
+    toPayload({ active, code, insertMethod, location, name, path, priority, shortcodeAttributes, tags, type, }) {
+        const placement = insertMethod === 'shortcode'
+            ? { 'shortcode_attributes': shortcodeAttributes }
+            : { location: wpcodeLocationTerm(type, location) };
         return {
-            code,
+            active,
+            code: stripPhpOpeningTag(code),
             note: `Imported from ${path}`,
-            tags: ['cli-import'],
+            priority,
+            tags,
             title: name,
             type,
+            ...placement,
+            'insert_method': insertMethod,
         };
     }
 }