@loopress/cli 0.7.0 → 0.9.0

package/dist/commands/snippet/push.js

@@ -1,9 +1,11 @@
-import { Args, Flags } from '@oclif/core';
-import got from 'got';
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
 import slugify from 'slugify';
 import { PushCommand } from '../../lib/push-command.js';
-import { getSnippetPlugin, parseType } from '../../utils/snippet-plugin.js';
+import { snippetPluginFlag } from '../../utils/snippet-plugin-flag.js';
+import { defaultLocationForType, getSnippetPlugin, parseInsertMethod, parseLocation, parseType, } from '../../utils/snippet-plugin.js';
 const TYPE_BY_EXTENSION = {
     '.css': 'css',
     '.html': 'html',
@@ -16,53 +18,38 @@ export default class Push extends PushCommand {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
     };
     static description = 'Push snippets to WordPress. Local snippet files created or updated remotely are renamed on disk to the `<id>-<slug>` convention.';
-    static examples = [
-        '$ lps snippet push',
-        '$ lps snippet push --url http://example.com',
-        '$ lps snippet push --path ./snippets',
-        '$ lps snippet push --plugin wpcode',
-    ];
+    static examples = ['$ lps snippet push', '$ lps snippet push --path ./snippets', '$ lps snippet push --plugin wpcode'];
     static flags = {
-        ...PushCommand.baseFlags,
-        'dry-run': Flags.boolean({ char: 'd', description: 'Show what would change without making changes' }),
-        plugin: Flags.string({
-            char: 'p',
-            description: 'WordPress snippet plugin to target (overrides loopress.json)',
-            options: ['code-snippets', 'wpcode'],
-        }),
+        ...PushCommand.dryRunFlag,
+        ...snippetPluginFlag,
     };
+    failedCount = 0;
     async run() {
         const { args, flags } = await this.parse(Push);
-        const dryRun = flags['dry-run'];
-        const { plugin } = flags;
-        this.dryRun = dryRun;
         const { url } = this.siteConfig;
-        const path = await this.resolveSnippetsPath(args.path);
-        const resolvedPlugin = await this.resolveSnippetPlugin(plugin);
-        this.log(`🚀 Pushing snippets to ${url} via ${resolvedPlugin}`);
-        this.log(`📂 From snippet path: ${path}`);
-        this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
-        let snippets = [];
-        try {
-            snippets = await this.loadSnippets(path);
-            this.log(`✅ Found ${snippets.length} snippets to push`);
-            const headers = await this.buildAuthHeaders();
-            const adapter = getSnippetPlugin(resolvedPlugin);
-            for (const snippet of snippets) {
-                await this.pushSnippet(snippet, { adapter, dryRun, headers, url });
-            }
-            await this.recordSuccess();
-            this.log('🎉 All snippets pushed successfully!');
-        }
-        catch (error) {
-            this.error(error.message);
+        const path = this.resolveSnippetsPath(args.path);
+        const resolvedPlugin = this.resolveSnippetPlugin(flags.plugin);
+        this.log(`Pushing snippets to ${url} via ${resolvedPlugin}`);
+        this.log(`Snippets path: ${path}`);
+        const snippets = await this.loadSnippets(path);
+        this.log(`Found ${snippets.length} snippet${snippets.length === 1 ? '' : 's'} to push`);
+        const adapter = getSnippetPlugin(resolvedPlugin);
+        await new Listr(snippets.map((snippet) => ({
+            task: async (_ctx, task) => this.pushSnippet(snippet, adapter, task),
+            title: `Push ${snippet.name}`,
+        })), { concurrent: false, exitOnError: false }).run();
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} snippet${this.failedCount === 1 ? '' : 's'} failed to push.`);
         }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All snippets pushed.');
     }
     // Renames the local file pair to the `<id>-<slug>` convention used by `snippet pull` whenever
     // it doesn't already match (e.g. a hand-created `demo.php` with no id, or a stale slug after a rename).
     // This is a side effect of `push`: local files on disk are renamed, not just the remote snippet.
     async ensureCanonicalFilename(snippet, id, name) {
-        const fs = await import('node:fs/promises');
         const dir = dirname(snippet.path);
         const ext = extname(snippet.path);
         const currentBase = basename(snippet.path, ext);
@@ -70,7 +57,7 @@ export default class Push extends PushCommand {
         const oldMetaPath = join(dir, `${currentBase}.json`);
         let meta = {};
         try {
-            const existing = await fs.readFile(oldMetaPath, 'utf8');
+            const existing = await readFile(oldMetaPath, 'utf8');
             meta = JSON.parse(existing);
         }
         catch (error) {
@@ -79,84 +66,110 @@ export default class Push extends PushCommand {
         }
         meta.id = id;
         meta.name = name;
-        if (currentBase === canonicalBase) {
-            await fs.writeFile(oldMetaPath, JSON.stringify(meta, null, 2) + '\n');
+        meta.type = snippet.type;
+        // Persist the id against the *current* file pairing before renaming anything, so a
+        // crash between the rename and the sidecar write still leaves a valid `<name>.<ext>` /
+        // `<name>.json` pair with the id on disk, and a retried `snippet push` won't re-create
+        // this snippet as a duplicate because it looks unlinked.
+        await writeFile(oldMetaPath, JSON.stringify(meta, null, 2) + '\n');
+        if (currentBase === canonicalBase)
             return;
-        }
         const newPath = join(dir, `${canonicalBase}${ext}`);
         const newMetaPath = join(dir, `${canonicalBase}.json`);
-        await fs.rename(snippet.path, newPath);
-        await fs.writeFile(newMetaPath, JSON.stringify(meta, null, 2) + '\n');
-        if (oldMetaPath !== newMetaPath)
-            await fs.rm(oldMetaPath, { force: true });
-        this.log(`📁 Renamed: ${snippet.path} → ${newPath}`);
+        await rename(snippet.path, newPath);
+        await writeFile(newMetaPath, JSON.stringify(meta, null, 2) + '\n');
+        await rm(oldMetaPath, { force: true });
     }
     async loadSnippets(path) {
-        const fs = await import('node:fs/promises');
         const snippets = [];
-        const SNIPPET_EXTENSIONS = new Set(Object.keys(TYPE_BY_EXTENSION));
         try {
-            const files = await fs.readdir(path);
+            const files = await readdir(path);
             for (const file of files) {
-                const ext = file.slice(file.lastIndexOf('.'));
-                if (!SNIPPET_EXTENSIONS.has(ext))
+                const ext = extname(file);
+                if (!(ext in TYPE_BY_EXTENSION))
                     continue;
-                const filePath = `${path}/${file}`;
-                const metaPath = filePath.slice(0, filePath.lastIndexOf('.')) + '.json';
-                const content = await fs.readFile(filePath, 'utf8');
+                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 fs.readFile(metaPath, 'utf8');
+                    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,
-                    name: name ?? file.slice(0, file.lastIndexOf('.')),
+                    insertMethod: insertMethod ?? 'auto',
+                    location: location ?? defaultLocationForType(resolvedType),
+                    name: name ?? basename(file, ext),
                     path: filePath,
-                    type: type ?? TYPE_BY_EXTENSION[ext] ?? 'php',
+                    priority,
+                    shortcodeAttributes,
+                    tags,
+                    type: resolvedType,
                 });
             }
         }
         catch (error) {
-            this.error(`❌ Error loading snippets: ${error.message}`);
+            this.error(`Error loading snippets: ${error.message}`);
         }
         return snippets;
     }
-    async pushSnippet(snippet, ctx) {
-        const { adapter, dryRun, headers, url } = ctx;
-        if (dryRun) {
-            this.log(`📝 [DRY RUN] Would push snippet: ${snippet.name}`);
-            this.log(`📄 Code preview: ${snippet.code.slice(0, 100)}...`);
+    // 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
+    // sibling snippets push regardless.
+    async pushSnippet(snippet, adapter, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${snippet.name}`;
             return;
         }
+        const endpointPath = adapter.endpointPath();
         try {
-            const endpoint = adapter.endpoint(url);
-            const payload = adapter.toPayload(snippet.name, snippet.code, snippet.path, snippet.type);
+            const payload = adapter.toPayload(snippet);
             if (snippet.id) {
-                this.log(`🔄 Updating snippet by id (${snippet.id}): ${snippet.name}`);
-                await got.put(`${endpoint}/${snippet.id}`, { headers, json: payload });
-                this.log(`✅ Updated: ${snippet.name}`);
+                await this.wp.put(`${endpointPath}/${snippet.id}`, payload);
                 await this.ensureCanonicalFilename(snippet, snippet.id, snippet.name);
-                return;
             }
-            this.log(`➕ Creating new snippet: ${snippet.name}`);
-            const response = await got.post(endpoint, { headers, json: payload }).json();
-            const created = adapter.fromRemote(response);
-            this.log(`✅ Created: ${snippet.name} (id: ${created.id})`);
-            await this.ensureCanonicalFilename(snippet, created.id, created.name);
+            else {
+                const response = await this.wp.post(endpointPath, payload);
+                const created = adapter.fromRemote(response);
+                await this.ensureCanonicalFilename(snippet, created.id, created.name);
+            }
+            if (task)
+                task.output = `Pushed: ${snippet.name}`;
         }
         catch (error) {
-            this.error(`❌ Error pushing snippet ${snippet.name}: ${error.message}`);
+            const message = `Failed to push ${snippet.name}: ${error.message}`;
+            if (task)
+                task.output = message;
+            else
+                this.warn(`  ${message}`);
+            this.failedCount++;
+            throw error;
         }
     }
 }

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

@@ -5,9 +5,7 @@ export interface ConsoleAuth {
 }
 export declare class AuthManager {
     private readonly homeDir;
-    private static instance;
     constructor(homeDir?: string);
-    static getInstance(): AuthManager;
     clearAuth(): void;
     getAuth(): ConsoleAuth | null;
     getAuthFilePath(): string;

package/dist/config/auth.manager.js

@@ -1,45 +1,25 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { readJsonFile, writeJsonFileAtomic } from './json-file.js';
 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;
-        }
+        return readJsonFile(this.getAuthFilePath());
     }
     getAuthFilePath() {
         return join(this.homeDir, '.loopress', 'auth.json');
     }
     setAuth(auth) {
-        const dir = join(this.homeDir, '.loopress');
-        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);
+        writeJsonFileAtomic(this.getAuthFilePath(), auth);
     }
 }
-export const authManager = AuthManager.getInstance();
+export const authManager = new AuthManager();

package/dist/config/json-file.d.ts

@@ -0,0 +1,2 @@
+export declare function readJsonFile<T>(filePath: string): null | T;
+export declare function writeJsonFileAtomic(filePath: string, data: unknown): void;

package/dist/config/json-file.js

@@ -0,0 +1,21 @@
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import writeFileAtomic from 'write-file-atomic';
+// Missing file or invalid JSON are treated as "no data" (returns null). Any other
+// read failure (permissions, EISDIR, ...) propagates instead of being swallowed.
+export function readJsonFile(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    const content = readFileSync(filePath, 'utf8');
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+// Mode 0o600 (owner read/write only) since these files hold auth tokens.
+export function writeJsonFileAtomic(filePath, data) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileAtomic.sync(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
+}

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

@@ -1,9 +1,7 @@
-import { EnvironmentConfig, LoopressConfig, ProjectConfig } from './types.js';
+import { EnvironmentConfig, LoopressConfig, ProjectConfig } from '../types/config.js';
 export declare class ProjectConfigManager {
     private readonly homeDir;
-    private static instance;
     constructor(homeDir?: string);
-    static getInstance(): ProjectConfigManager;
     createProjectId(): string;
     ensureConfigDir(): void;
     getConfigFilePath(): string;

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

@@ -1,19 +1,13 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+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();
     }
@@ -73,17 +67,11 @@ export class ProjectConfigManager {
         }));
     }
     readConfig() {
-        const filePath = this.getConfigFilePath();
-        if (!existsSync(filePath)) {
-            return { currentProject: null, projects: {} };
-        }
-        try {
-            const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
-            return this.sanitizeConfig(parsed);
-        }
-        catch {
+        const parsed = readJsonFile(this.getConfigFilePath());
+        if (parsed === null) {
             return { currentProject: null, projects: {} };
         }
+        return this.sanitizeConfig(parsed);
     }
     removeEnvironment(projectId, envName) {
         const config = this.readConfig();
@@ -136,11 +124,7 @@ export class ProjectConfigManager {
         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)
@@ -174,4 +158,4 @@ export class ProjectConfigManager {
         return projects;
     }
 }
-export const configManager = ProjectConfigManager.getInstance();
+export const configManager = new ProjectConfigManager();

package/dist/hooks/finally.d.ts

@@ -0,0 +1,3 @@
+import type { Hook } from '@oclif/core';
+declare const hook: Hook.Finally;
+export default hook;

package/dist/hooks/finally.js

@@ -0,0 +1,21 @@
+import * as Sentry from '@sentry/node';
+import { isTelemetryDisabled, runtimeContext } from '../lib/sentry.js';
+// oclif has no `command_error` hook (checked @oclif/core@4.11.11's hooks.d.ts). `finally`
+// is the closest equivalent: it always runs at the end of the CLI lifecycle and carries
+// the error, if any, so it's where we report crashes before the process exits.
+const hook = async function (options) {
+    if (!options.error || isTelemetryDisabled())
+        return;
+    try {
+        Sentry.captureException(options.error, {
+            contexts: { runtime: runtimeContext() },
+            extra: { argv: options.argv },
+            tags: { command: options.id },
+        });
+        await Sentry.flush(2000);
+    }
+    catch (error) {
+        this.debug('Failed to report error to Sentry: %O', error);
+    }
+};
+export default hook;

package/dist/hooks/init.d.ts

@@ -0,0 +1,3 @@
+import type { Hook } from '@oclif/core';
+declare const hook: Hook.Init;
+export default hook;

package/dist/hooks/init.js

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/node';
+import { consumeErrorReportingFlag, isTelemetryDisabled, resolveEnvironment, SENTRY_DSN } from '../lib/sentry.js';
+const hook = async function (options) {
+    consumeErrorReportingFlag(options.argv);
+    if (isTelemetryDisabled())
+        return;
+    try {
+        Sentry.init({
+            dsn: SENTRY_DSN,
+            environment: resolveEnvironment(),
+            release: this.config.version,
+        });
+    }
+    catch (error) {
+        this.debug('Failed to initialize Sentry: %O', error);
+    }
+};
+export default hook;

package/dist/lib/base.d.ts

@@ -1,14 +1,19 @@
 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,70 +2,72 @@ 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`)',
-            helpGroup: 'GLOBAL',
-        }),
-        url: Flags.string({
-            description: 'WordPress URL (fallback; prefer `lps project config`)',
-            helpGroup: 'GLOBAL',
-        }),
-        user: Flags.string({
-            description: 'WordPress username (fallback; prefer `lps project config`)',
-            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();
+        this.siteConfig = this.resolveEnvironment();
+    }
+    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/sentry.d.ts

@@ -0,0 +1,8 @@
+export declare const SENTRY_DSN = "https://a08dd56bfffc2a45d5b8f665e4cb8b7d@o4511586904309760.ingest.de.sentry.io/4511673275973712";
+export declare function consumeErrorReportingFlag(argv: string[]): void;
+export declare function isTelemetryDisabled(): boolean;
+export declare function resolveEnvironment(): string;
+export declare function runtimeContext(): {
+    node: string;
+    os: string;
+};