@loopress/cli 0.6.0 → 0.8.0

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

@@ -1,17 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 export class ProjectConfigManager {
     homeDir;
-    static instance;
     constructor(homeDir = homedir()) {
         this.homeDir = homeDir;
     }
-    static getInstance() {
-        if (!ProjectConfigManager.instance) {
-            ProjectConfigManager.instance = new ProjectConfigManager();
-        }
-        return ProjectConfigManager.instance;
+    createProjectId() {
+        return randomUUID();
     }
     ensureConfigDir() {
         const dir = join(this.homeDir, '.loopress');
@@ -23,108 +21,141 @@ export class ProjectConfigManager {
         return join(this.homeDir, '.loopress', 'config.json');
     }
     getCurrentEnv() {
-        const project = this.getCurrentProject();
-        if (!project || !project.currentEnv)
+        const config = this.readConfig();
+        if (!config.currentProject)
             return null;
-        return project.environments[project.currentEnv] ?? null;
+        const project = config.projects[config.currentProject.id];
+        if (!project)
+            return null;
+        return project.environments[config.currentProject.env] ?? null;
     }
     getCurrentProject() {
         const config = this.readConfig();
-        if (!config.currentProject || !config.projects[config.currentProject])
+        if (!config.currentProject)
             return null;
-        return config.projects[config.currentProject];
+        const project = config.projects[config.currentProject.id];
+        if (!project)
+            return null;
+        return { ...project, id: config.currentProject.id };
     }
-    getEnvironment(projectName, envName) {
-        const project = this.getProject(projectName);
+    getEnvironment(projectId, envName) {
+        const project = this.getProject(projectId);
         if (!project)
             return null;
         return project.environments[envName] ?? null;
     }
-    getProject(name) {
+    getProject(id) {
         const config = this.readConfig();
-        return config.projects[name] ?? null;
+        return config.projects[id] ?? null;
     }
-    listEnvironments(projectName) {
-        const project = this.getProject(projectName);
+    listEnvironments(projectId) {
+        const config = this.readConfig();
+        const project = config.projects[projectId];
         if (!project)
             return [];
         return Object.values(project.environments).map((env) => ({
             ...env,
-            isCurrent: env.name === project.currentEnv,
+            isCurrent: config.currentProject?.id === projectId && config.currentProject.env === env.name,
         }));
     }
     listProjects() {
         const config = this.readConfig();
-        return Object.values(config.projects).map((project) => ({
+        return Object.entries(config.projects).map(([id, project]) => ({
             ...project,
-            isCurrent: project.name === config.currentProject,
+            id,
+            isCurrent: config.currentProject?.id === id,
         }));
     }
     readConfig() {
-        const filePath = this.getConfigFilePath();
-        if (!existsSync(filePath)) {
+        const parsed = readJsonFile(this.getConfigFilePath());
+        if (parsed === null) {
             return { currentProject: null, projects: {} };
         }
-        return JSON.parse(readFileSync(filePath, 'utf8'));
+        return this.sanitizeConfig(parsed);
     }
-    removeEnvironment(projectName, envName) {
+    removeEnvironment(projectId, envName) {
         const config = this.readConfig();
-        if (!config.projects[projectName])
+        const project = config.projects[projectId];
+        if (!project)
             return;
-        const project = config.projects[projectName];
         delete project.environments[envName];
-        if (project.currentEnv === envName) {
+        if (config.currentProject?.id === projectId && config.currentProject.env === envName) {
             const remaining = Object.keys(project.environments);
-            project.currentEnv = remaining.length > 0 ? remaining[0] : null;
+            config.currentProject = remaining.length > 0 ? { env: remaining[0], id: projectId } : null;
         }
         this.writeConfig(config);
     }
-    removeProject(name) {
+    removeProject(id) {
         const config = this.readConfig();
-        delete config.projects[name];
-        if (config.currentProject === name) {
-            const remaining = Object.keys(config.projects);
-            config.currentProject = remaining.length > 0 ? remaining[0] : null;
+        delete config.projects[id];
+        if (config.currentProject?.id === id) {
+            const [nextId] = Object.keys(config.projects);
+            const nextProject = nextId ? config.projects[nextId] : undefined;
+            const [nextEnv] = nextProject ? Object.keys(nextProject.environments) : [];
+            config.currentProject = nextId && nextEnv ? { env: nextEnv, id: nextId } : null;
         }
         this.writeConfig(config);
     }
-    setCurrentEnv(projectName, envName) {
+    setCurrent(projectId, envName) {
         const config = this.readConfig();
-        if (!config.projects[projectName])
+        if (!config.projects[projectId])
             return;
-        config.projects[projectName].currentEnv = envName;
-        this.writeConfig(config);
-    }
-    setCurrentProject(name) {
-        const config = this.readConfig();
-        config.currentProject = name;
+        config.currentProject = { env: envName, id: projectId };
         this.writeConfig(config);
     }
-    setEnvironment(projectName, envName, env) {
+    setEnvironment(projectId, envName, env) {
         const config = this.readConfig();
-        if (!config.projects[projectName])
+        const project = config.projects[projectId];
+        if (!project)
             return;
-        const project = config.projects[projectName];
-        const isFirst = Object.keys(project.environments).length === 0;
         project.environments[envName] = env;
-        if (isFirst)
-            project.currentEnv = envName;
+        if (!config.currentProject)
+            config.currentProject = { env: envName, id: projectId };
         this.writeConfig(config);
     }
-    setProject(name, project) {
+    setProject(id, project) {
         const config = this.readConfig();
-        const isFirst = Object.keys(config.projects).length === 0;
-        config.projects[name] = project;
-        if (isFirst)
-            config.currentProject = name;
+        config.projects[id] = project;
+        if (!config.currentProject) {
+            const [firstEnv] = Object.keys(project.environments);
+            if (firstEnv)
+                config.currentProject = { env: firstEnv, id };
+        }
         this.writeConfig(config);
     }
     writeConfig(config) {
-        this.ensureConfigDir();
-        const filePath = this.getConfigFilePath();
-        const tmpPath = `${filePath}.tmp`;
-        writeFileSync(tmpPath, JSON.stringify(config, null, 2));
-        renameSync(tmpPath, filePath);
+        writeJsonFileAtomic(this.getConfigFilePath(), config);
+    }
+    isProjectConfig(value) {
+        if (typeof value !== 'object' || value === null)
+            return false;
+        const candidate = value;
+        return typeof candidate.name === 'string' && typeof candidate.environments === 'object' && candidate.environments !== null;
+    }
+    sanitizeConfig(value) {
+        if (typeof value !== 'object' || value === null)
+            return { currentProject: null, projects: {} };
+        const candidate = value;
+        return {
+            currentProject: this.sanitizeCurrentProject(candidate.currentProject),
+            projects: this.sanitizeProjects(candidate.projects),
+        };
+    }
+    sanitizeCurrentProject(value) {
+        if (value === null || typeof value !== 'object')
+            return null;
+        const pointer = value;
+        return typeof pointer.id === 'string' && typeof pointer.env === 'string' ? { env: pointer.env, id: pointer.id } : null;
+    }
+    sanitizeProjects(value) {
+        if (typeof value !== 'object' || value === null)
+            return {};
+        const projects = {};
+        for (const [id, project] of Object.entries(value)) {
+            if (this.isProjectConfig(project))
+                projects[id] = project;
+        }
+        return projects;
     }
 }
-export const configManager = ProjectConfigManager.getInstance();
+export const configManager = new ProjectConfigManager();

package/dist/lib/base.d.ts

@@ -1,14 +1,24 @@
 import { Command } from '@oclif/core';
-import { EnvironmentConfig } from '../config/types.js';
+import { EnvironmentConfig } from '../types/config.js';
+import { LoopressLocalConfig } from '../utils/loopress-config.js';
+import { WpClient } from './wp-client.js';
 export declare abstract class LoopressCommand extends Command {
     static baseFlags: {
         password: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         user: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static dryRunFlag: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected dryRun: boolean;
+    protected localConfig: LoopressLocalConfig;
     protected siteConfig: EnvironmentConfig;
-    buildAuthHeaders(): Promise<Record<string, string>>;
+    private wpClient?;
+    protected get rootDir(): string;
+    protected get wp(): WpClient;
     init(): Promise<void>;
-    protected resolveSnippetPlugin(flag?: string): Promise<'code-snippets' | 'wpcode'>;
-    protected resolveSnippetsPath(override?: string): Promise<string>;
+    protected resolveSnippetPlugin(flag?: string): 'code-snippets' | 'wpcode';
+    protected resolveSnippetsPath(override?: string): string;
+    private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -2,60 +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);
-            if (!project) {
-                this.error(`Project "${localConfig.projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
-            }
-            if (!project.currentEnv || !project.environments[project.currentEnv]) {
-                this.error(`Project "${localConfig.projectId}" has no active environment. Run \`lps project config\` to configure one.`);
-            }
-            this.siteConfig = project.environments[project.currentEnv];
-            return;
+        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 env = configManager.getCurrentEnv();
-        if (env) {
-            this.siteConfig = env;
+        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;
         }
-        this.error('No environment configured. Run `lps project config` first.');
+        const env = this.resolveEnvironment();
+        this.siteConfig = flagToken ? { ...env, token: flagToken } : env;
     }
-    async resolveSnippetPlugin(flag) {
+    resolveSnippetPlugin(flag) {
         if (flag)
             return flag;
-        const config = await readLocalConfig();
-        return config.snippetPlugin ?? 'wpcode';
+        return this.localConfig.snippetPlugin ?? 'wpcode';
     }
-    async resolveSnippetsPath(override) {
+    resolveSnippetsPath(override) {
         if (override)
             return override;
-        const config = await readLocalConfig();
-        return join(config.rootDir ?? '.', config.snippetsDir ?? 'snippets');
+        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 "${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) {
+                return project.environments[envNames[0]];
+            }
+            const current = configManager.getCurrentProject();
+            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.`);
+            }
+            return currentEnv;
+        }
+        const env = configManager.getCurrentEnv();
+        if (env)
+            return env;
+        this.error('No environment configured. Run `lps project config` first.');
     }
 }

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/{config/types.d.ts → types/config.d.ts}

@@ -6,11 +6,14 @@ export interface EnvironmentConfig {
 }
 export interface ProjectConfig {
     addedAt: string;
-    currentEnv: null | string;
     environments: Record<string, EnvironmentConfig>;
     name: string;
 }
+export interface CurrentProjectPointer {
+    env: string;
+    id: string;
+}
 export interface LoopressConfig {
-    currentProject: null | string;
+    currentProject: CurrentProjectPointer | null;
     projects: Record<string, ProjectConfig>;
 }

package/dist/types/snippet.d.ts

@@ -1,6 +1,14 @@
+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,17 +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): Record<string, unknown>;
+    toPayload(snippet: SnippetPayloadInput): Record<string, unknown>;
 }
 export declare function getSnippetPlugin(name: PluginName): SnippetPlugin;