@loopress/cli 0.1.0

package/dist/commands/snippets/push.d.ts

@@ -0,0 +1,18 @@
+import { LoopressCommand } from '../base.js';
+export default class Push extends LoopressCommand {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        plugin: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+    };
+    run(): Promise<void>;
+    private loadSnippets;
+    private pushSnippet;
+}

package/dist/commands/snippets/push.js

@@ -0,0 +1,97 @@
+import { Args, Flags } from '@oclif/core';
+import got from 'got';
+import { getSnippetPlugin } from '../../utils/snippet-plugin.js';
+import { LoopressCommand } from '../base.js';
+export default class Push extends LoopressCommand {
+    static args = {
+        path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
+    };
+    static description = 'Push snippets to WordPress';
+    static examples = [
+        '$ lps snippets push',
+        '$ lps snippets push --url http://example.com',
+        '$ lps snippets push --path ./snippets',
+        '$ lps snippets push --plugin wpcode',
+    ];
+    static flags = {
+        ...LoopressCommand.baseFlags,
+        dryRun: Flags.boolean({ char: 'd', description: 'Dry run - show what would happen without making changes' }),
+        plugin: Flags.string({
+            char: 'p',
+            default: 'code-snippets',
+            description: 'WordPress snippet plugin to target',
+            options: ['code-snippets', 'wpcode'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Push);
+        const { dryRun, plugin } = flags;
+        const { url } = this.siteConfig;
+        const path = await this.resolveSnippetsPath(args.path);
+        this.log(`🚀 Pushing snippets to ${url} via ${plugin}`);
+        this.log(`📂 From snippet path: ${path}`);
+        this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
+        try {
+            const snippets = await this.loadSnippets(path);
+            this.log(`✅ Found ${snippets.length} snippets to push`);
+            const headers = await this.buildAuthHeaders();
+            const adapter = getSnippetPlugin(plugin);
+            for (const snippet of snippets) {
+                await this.pushSnippet(snippet, url, headers, dryRun, adapter);
+            }
+            this.log('🎉 All snippets pushed successfully!');
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+    }
+    async loadSnippets(path) {
+        const fs = await import('node:fs/promises');
+        const snippets = [];
+        try {
+            const files = await fs.readdir(path);
+            for (const file of files) {
+                if (file.endsWith('.php')) {
+                    const filePath = `${path}/${file}`;
+                    const content = await fs.readFile(filePath, 'utf8');
+                    snippets.push({
+                        code: content,
+                        name: file.replace('.php', ''),
+                        path: filePath,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.error(`❌ Error loading snippets: ${error.message}`);
+        }
+        return snippets;
+    }
+    async pushSnippet(snippet, url, headers, dryRun, adapter) {
+        if (dryRun) {
+            this.log(`📝 [DRY RUN] Would push snippet: ${snippet.name}`);
+            this.log(`📄 Code preview: ${snippet.code.slice(0, 100)}...`);
+            return;
+        }
+        try {
+            const endpoint = adapter.endpoint(url);
+            const remoteList = await got.get(endpoint, { headers }).json();
+            const existing = remoteList
+                .map((r) => adapter.fromRemote(r))
+                .find((s) => s.name === snippet.name);
+            const payload = adapter.toPayload(snippet.name, snippet.code, snippet.path);
+            if (existing) {
+                this.log(`🔄 Updating existing snippet: ${snippet.name}`);
+                await got.put(`${endpoint}/${existing.id}`, { headers, json: payload });
+            }
+            else {
+                this.log(`➕ Creating new snippet: ${snippet.name}`);
+                await got.post(endpoint, { headers, json: payload });
+            }
+            this.log(`✅ ${existing ? 'Updated' : 'Created'}: ${snippet.name}`);
+        }
+        catch (error) {
+            this.error(`❌ Error pushing snippet ${snippet.name}: ${error.message}`);
+        }
+    }
+}

package/dist/commands/styles/pull.d.ts

@@ -0,0 +1,12 @@
+import { LoopressCommand } from '../base.js';
+export default class Pull extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/styles/pull.js

@@ -0,0 +1,52 @@
+import { Flags } from '@oclif/core';
+import got from 'got';
+import { LoopressCommand } from '../base.js';
+export default class Pull extends LoopressCommand {
+    static description = 'Pull Global Styles from WordPress';
+    static examples = ['$ lps styles pull', '$ lps styles pull --url http://example.com'];
+    static flags = {
+        ...LoopressCommand.baseFlags,
+        dryRun: Flags.boolean({ char: 'd', description: 'Dry run - show what would happen without making changes' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pull);
+        const { dryRun } = flags;
+        const { url } = this.siteConfig;
+        const stylesDir = await this.resolveStylesPath();
+        const outputPath = `${stylesDir}/global-styles.json`;
+        this.log(`📥 Pulling Global Styles from ${url}`);
+        this.log(`📂 Target file: ${outputPath}`);
+        this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
+        try {
+            const headers = await this.buildAuthHeaders();
+            this.log('🔍 Finding active theme...');
+            const themes = await got.get(`${url}/wp-json/wp/v2/themes?status=active`, { headers }).json();
+            if (!themes || themes.length === 0) {
+                this.error('❌ No active theme found.');
+            }
+            const activeTheme = themes[0];
+            const globalStylesEndpoint = activeTheme._links['wp:user-global-styles'][0].href;
+            if (!globalStylesEndpoint) {
+                this.error(`❌ Active theme "${activeTheme.name}" does not have global styles endpoint.`);
+            }
+            const globalStyles = await got.get(globalStylesEndpoint, { headers }).json();
+            const dataToSave = {
+                id: globalStyles.id,
+                settings: globalStyles.settings,
+                styles: globalStyles.styles,
+            };
+            if (dryRun) {
+                this.log(`📝 [DRY RUN] Would pull styles and settings for ID: ${globalStyles.id}`);
+                this.log(`📄 Data preview: ${JSON.stringify(dataToSave).slice(0, 100)}...`);
+                return;
+            }
+            const fs = await import('node:fs/promises');
+            await fs.mkdir(stylesDir, { recursive: true });
+            await fs.writeFile(outputPath, JSON.stringify(dataToSave, null, 2));
+            this.log(`✅ Successfully pulled global styles to ${outputPath}`);
+        }
+        catch (error) {
+            this.error(`❌ Error pulling global styles: ${error.message}`);
+        }
+    }
+}

package/dist/commands/styles/push.d.ts

@@ -0,0 +1,13 @@
+import { LoopressCommand } from '../base.js';
+export default class Push extends LoopressCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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>;
+    };
+    run(): Promise<void>;
+    private readOrFetchGlobalStyles;
+}

package/dist/commands/styles/push.js

@@ -0,0 +1,78 @@
+import { Flags } from '@oclif/core';
+import { glob } from 'glob';
+import got from 'got';
+import { LoopressCommand } from '../base.js';
+export default class Push extends LoopressCommand {
+    static description = 'Push Global Styles to WordPress';
+    static examples = ['$ lps styles push', '$ lps styles push --url http://example.com'];
+    static flags = {
+        ...LoopressCommand.baseFlags,
+        dryRun: Flags.boolean({ char: 'd', description: 'Dry run - show what would happen without making changes' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Push);
+        const { dryRun } = flags;
+        const { url } = this.siteConfig;
+        const stylesDir = await this.resolveStylesPath();
+        const jsonPath = `${stylesDir}/global-styles.json`;
+        this.log(`📤 Pushing Global Styles to ${url}`);
+        this.log(`📂 From directory: ${stylesDir}`);
+        this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
+        try {
+            const fs = await import('node:fs/promises');
+            const headers = await this.buildAuthHeaders();
+            const data = await this.readOrFetchGlobalStyles(jsonPath, url, headers, fs);
+            this.log('🎨 Bundling CSS files in memory...');
+            const cssFiles = await glob(`${stylesDir}/**/*.css`);
+            let bundledCss = '';
+            if (cssFiles.length > 0) {
+                const cssContents = await Promise.all(cssFiles.map((file) => fs.readFile(file, 'utf8')));
+                bundledCss = cssContents.join('\n').trim();
+                this.log(`✨ Bundled ${cssFiles.length} CSS files`);
+            }
+            else {
+                this.log(`⚠️ No CSS files found in ${stylesDir}/**/*.css`);
+            }
+            const endpoint = `${url}/wp-json/wp/v2/global-styles/${data.id}`;
+            const payload = {
+                settings: data.settings,
+                styles: {
+                    ...data.styles,
+                    ...(bundledCss ? { css: bundledCss } : {}),
+                },
+            };
+            if (dryRun) {
+                this.log(`📝 [DRY RUN] Would push to ${endpoint}`);
+                this.log(`📄 Payload preview: ${JSON.stringify(payload).slice(0, 100)}...`);
+                return;
+            }
+            await got.post(endpoint, { headers, json: payload });
+            this.log(`✅ Successfully pushed global styles to ID: ${data.id}`);
+        }
+        catch (error) {
+            this.error(`❌ Error pushing global styles: ${error.message}`);
+        }
+    }
+    async readOrFetchGlobalStyles(jsonPath, url, headers, fs) {
+        try {
+            const content = await fs.readFile(jsonPath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        this.log('ℹ️  No local cache found — fetching global styles from WordPress...');
+        const themes = await got.get(`${url}/wp-json/wp/v2/themes?status=active`, { headers }).json();
+        if (!themes || themes.length === 0) {
+            this.error('❌ No active theme found.');
+        }
+        const globalStylesEndpoint = themes[0]._links['wp:user-global-styles'][0].href;
+        const globalStyles = await got.get(globalStylesEndpoint, { headers }).json();
+        const data = { id: globalStyles.id, settings: globalStyles.settings, styles: globalStyles.styles };
+        await fs.mkdir(jsonPath.replace(/\/[^/]+$/, ''), { recursive: true });
+        await fs.writeFile(jsonPath, JSON.stringify(data, null, 2));
+        this.log(`💾 Cached to ${jsonPath}`);
+        return data;
+    }
+}

package/dist/config/auth.manager.d.ts

@@ -0,0 +1,16 @@
+export interface ConsoleAuth {
+    email?: string;
+    savedAt: string;
+    token: string;
+}
+export declare class AuthManager {
+    private readonly homeDir;
+    private static instance;
+    constructor(homeDir?: string);
+    static getInstance(): AuthManager;
+    clearAuth(): void;
+    getAuth(): ConsoleAuth | null;
+    getAuthFilePath(): string;
+    setAuth(auth: ConsoleAuth): void;
+}
+export declare const authManager: AuthManager;

package/dist/config/auth.manager.js

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export class AuthManager {
+    homeDir;
+    static instance;
+    constructor(homeDir = homedir()) {
+        this.homeDir = homeDir;
+    }
+    static getInstance() {
+        if (!AuthManager.instance) {
+            AuthManager.instance = new AuthManager();
+        }
+        return AuthManager.instance;
+    }
+    clearAuth() {
+        const filePath = this.getAuthFilePath();
+        if (existsSync(filePath))
+            unlinkSync(filePath);
+    }
+    getAuth() {
+        const filePath = this.getAuthFilePath();
+        if (!existsSync(filePath))
+            return null;
+        try {
+            return JSON.parse(readFileSync(filePath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    getAuthFilePath() {
+        return join(this.homeDir, '.lps', 'auth.json');
+    }
+    setAuth(auth) {
+        const dir = join(this.homeDir, '.lps');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const filePath = this.getAuthFilePath();
+        const tmpPath = `${filePath}.tmp`;
+        writeFileSync(tmpPath, JSON.stringify(auth, null, 2));
+        renameSync(tmpPath, filePath);
+    }
+}
+export const authManager = AuthManager.getInstance();

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

@@ -0,0 +1,28 @@
+import { EnvironmentConfig, LoopressConfig, ProjectConfig } from './types.js';
+export declare class ProjectConfigManager {
+    private readonly homeDir;
+    private static instance;
+    constructor(homeDir?: string);
+    static getInstance(): ProjectConfigManager;
+    ensureConfigDir(): void;
+    getConfigFilePath(): string;
+    getCurrentEnv(): EnvironmentConfig | null;
+    getCurrentProject(): null | ProjectConfig;
+    getEnvironment(projectName: string, envName: string): EnvironmentConfig | null;
+    getProject(name: string): null | ProjectConfig;
+    listEnvironments(projectName: string): Array<EnvironmentConfig & {
+        isCurrent: boolean;
+    }>;
+    listProjects(): Array<ProjectConfig & {
+        isCurrent: boolean;
+    }>;
+    readConfig(): LoopressConfig;
+    removeEnvironment(projectName: string, envName: string): void;
+    removeProject(name: string): void;
+    setCurrentEnv(projectName: string, envName: string): void;
+    setCurrentProject(name: string): void;
+    setEnvironment(projectName: string, envName: string, env: EnvironmentConfig): void;
+    setProject(name: string, project: ProjectConfig): void;
+    writeConfig(config: LoopressConfig): void;
+}
+export declare const configManager: ProjectConfigManager;

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

@@ -0,0 +1,130 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export class ProjectConfigManager {
+    homeDir;
+    static instance;
+    constructor(homeDir = homedir()) {
+        this.homeDir = homeDir;
+    }
+    static getInstance() {
+        if (!ProjectConfigManager.instance) {
+            ProjectConfigManager.instance = new ProjectConfigManager();
+        }
+        return ProjectConfigManager.instance;
+    }
+    ensureConfigDir() {
+        const dir = join(this.homeDir, '.lps');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    getConfigFilePath() {
+        return join(this.homeDir, '.lps', 'config.json');
+    }
+    getCurrentEnv() {
+        const project = this.getCurrentProject();
+        if (!project || !project.currentEnv)
+            return null;
+        return project.environments[project.currentEnv] ?? null;
+    }
+    getCurrentProject() {
+        const config = this.readConfig();
+        if (!config.currentProject || !config.projects[config.currentProject])
+            return null;
+        return config.projects[config.currentProject];
+    }
+    getEnvironment(projectName, envName) {
+        const project = this.getProject(projectName);
+        if (!project)
+            return null;
+        return project.environments[envName] ?? null;
+    }
+    getProject(name) {
+        const config = this.readConfig();
+        return config.projects[name] ?? null;
+    }
+    listEnvironments(projectName) {
+        const project = this.getProject(projectName);
+        if (!project)
+            return [];
+        return Object.values(project.environments).map((env) => ({
+            ...env,
+            isCurrent: env.name === project.currentEnv,
+        }));
+    }
+    listProjects() {
+        const config = this.readConfig();
+        return Object.values(config.projects).map((project) => ({
+            ...project,
+            isCurrent: project.name === config.currentProject,
+        }));
+    }
+    readConfig() {
+        const filePath = this.getConfigFilePath();
+        if (!existsSync(filePath)) {
+            return { currentProject: null, projects: {} };
+        }
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    removeEnvironment(projectName, envName) {
+        const config = this.readConfig();
+        if (!config.projects[projectName])
+            return;
+        const project = config.projects[projectName];
+        delete project.environments[envName];
+        if (project.currentEnv === envName) {
+            const remaining = Object.keys(project.environments);
+            project.currentEnv = remaining.length > 0 ? remaining[0] : null;
+        }
+        this.writeConfig(config);
+    }
+    removeProject(name) {
+        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;
+        }
+        this.writeConfig(config);
+    }
+    setCurrentEnv(projectName, envName) {
+        const config = this.readConfig();
+        if (!config.projects[projectName])
+            return;
+        config.projects[projectName].currentEnv = envName;
+        this.writeConfig(config);
+    }
+    setCurrentProject(name) {
+        const config = this.readConfig();
+        config.currentProject = name;
+        this.writeConfig(config);
+    }
+    setEnvironment(projectName, envName, env) {
+        const config = this.readConfig();
+        if (!config.projects[projectName])
+            return;
+        const project = config.projects[projectName];
+        const isFirst = Object.keys(project.environments).length === 0;
+        project.environments[envName] = env;
+        if (isFirst)
+            project.currentEnv = envName;
+        this.writeConfig(config);
+    }
+    setProject(name, project) {
+        const config = this.readConfig();
+        const isFirst = Object.keys(config.projects).length === 0;
+        config.projects[name] = project;
+        if (isFirst)
+            config.currentProject = name;
+        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);
+    }
+}
+export const configManager = ProjectConfigManager.getInstance();

package/dist/config/types.d.ts

@@ -0,0 +1,16 @@
+export interface EnvironmentConfig {
+    addedAt: string;
+    name: string;
+    token?: string;
+    url: string;
+}
+export interface ProjectConfig {
+    addedAt: string;
+    currentEnv: null | string;
+    environments: Record<string, EnvironmentConfig>;
+    name: string;
+}
+export interface LoopressConfig {
+    currentProject: null | string;
+    projects: Record<string, ProjectConfig>;
+}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/types/menu.d.ts

@@ -0,0 +1,7 @@
+export interface NavMenu {
+    [key: string]: any;
+    description?: string;
+    id: number;
+    name: string;
+    slug: string;
+}

package/dist/types/menu.js

@@ -0,0 +1 @@
+export {};

package/dist/types/snippet.d.ts

@@ -0,0 +1,6 @@
+export interface Snippet {
+    code: string;
+    id?: number;
+    name: string;
+    path: string;
+}

package/dist/types/snippet.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/loopress-config.d.ts

@@ -0,0 +1,6 @@
+export interface LoopressLocalConfig {
+    rootDir?: string;
+    snippets?: string;
+    styles?: string;
+}
+export declare function readLocalConfig(): Promise<LoopressLocalConfig>;

package/dist/utils/loopress-config.js

@@ -0,0 +1,14 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export async function readLocalConfig() {
+    const configPath = join(process.cwd(), 'loopress.config.js');
+    if (!existsSync(configPath))
+        return {};
+    try {
+        const mod = await import(configPath);
+        return mod.default ?? {};
+    }
+    catch {
+        return {};
+    }
+}

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

@@ -0,0 +1,15 @@
+export type PluginName = 'code-snippets' | 'wpcode';
+export interface NormalizedSnippet {
+    active: boolean;
+    code: string;
+    description: string;
+    id: number;
+    name: string;
+    tags: string[];
+}
+export interface SnippetPlugin {
+    endpoint(siteUrl: string): string;
+    fromRemote(data: Record<string, unknown>): NormalizedSnippet;
+    toPayload(name: string, code: string, path: string): Record<string, unknown>;
+}
+export declare function getSnippetPlugin(name: PluginName): SnippetPlugin;

package/dist/utils/snippet-plugin.js

@@ -0,0 +1,58 @@
+class CodeSnippetsPlugin {
+    endpoint(siteUrl) {
+        return `${siteUrl}/wp-json/code-snippets/v1/snippets`;
+    }
+    fromRemote(data) {
+        return {
+            active: Boolean(data.active),
+            code: String(data.code ?? ''),
+            description: String(data.desc ?? ''),
+            id: Number(data.id),
+            name: String(data.name ?? ''),
+            tags: Array.isArray(data.tags) ? data.tags : [],
+        };
+    }
+    toPayload(name, code, path) {
+        return {
+            code,
+            desc: `Imported from ${path}`,
+            name,
+            tags: ['cli-import'],
+        };
+    }
+}
+class WPCodePlugin {
+    endpoint(siteUrl) {
+        return `${siteUrl}/wp-json/loopress/v1/wpcode/snippets`;
+    }
+    fromRemote(data) {
+        return {
+            active: Boolean(data.active),
+            code: String(data.code ?? ''),
+            description: String(data.note ?? ''),
+            id: Number(data.id),
+            name: String(data.title ?? ''),
+            tags: Array.isArray(data.tags) ? data.tags : [],
+        };
+    }
+    toPayload(name, code, path) {
+        return {
+            code,
+            note: `Imported from ${path}`,
+            tags: ['cli-import'],
+            title: name,
+            type: 'php',
+        };
+    }
+}
+export function getSnippetPlugin(name) {
+    switch (name) {
+        case 'wpcode': {
+            return new WPCodePlugin();
+        }
+        case 'code-snippets':
+        default: {
+            return new CodeSnippetsPlugin();
+        }
+    }
+}