@loopress/cli 0.6.0 → 0.8.0

package/dist/commands/snippet/pull.js

@@ -1,7 +1,9 @@
-import { Args, Flags } from '@oclif/core';
-import got from 'got';
+import { Args } from '@oclif/core';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import slugify from 'slugify';
 import { LoopressCommand } from '../../lib/base.js';
+import { snippetPluginFlag } from '../../utils/snippet-plugin-flag.js';
 import { getSnippetPlugin } from '../../utils/snippet-plugin.js';
 const EXTENSIONS = {
     css: 'css',
@@ -22,11 +24,18 @@ export function buildMetaFile(snippet) {
         name: snippet.name,
         type: snippet.type,
         active: snippet.active,
+        location: snippet.location,
     };
     if (snippet.description)
         meta.description = snippet.description;
     if (snippet.tags.length > 0)
         meta.tags = snippet.tags;
+    if (snippet.insertMethod === 'shortcode')
+        meta.insertMethod = snippet.insertMethod;
+    if (snippet.priority !== 10)
+        meta.priority = snippet.priority;
+    if (snippet.shortcodeAttributes.length > 0)
+        meta.shortcodeAttributes = snippet.shortcodeAttributes;
     return JSON.stringify(meta, null, 2) + '\n';
 }
 export default class Pull extends LoopressCommand {
@@ -35,66 +44,49 @@ export default class Pull extends LoopressCommand {
     };
     static description = 'Pull snippets from WordPress';
     static examples = [
-        '$ lps snippets pull',
-        '$ lps snippets pull --url http://example.com',
-        '$ lps snippets pull --path ./snippets',
-        '$ lps snippets pull --plugin wpcode',
+        '$ lps snippet pull',
+        '$ lps snippet pull --url http://example.com',
+        '$ lps snippet pull --path ./snippets',
+        '$ lps snippet pull --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',
-            description: 'WordPress snippet plugin to target (overrides loopress.json)',
-            options: ['code-snippets', 'wpcode'],
-        }),
+        ...LoopressCommand.dryRunFlag,
+        ...snippetPluginFlag,
     };
     async run() {
         const { args, flags } = await this.parse(Pull);
-        const { dryRun, plugin } = flags;
         const { url } = this.siteConfig;
-        const path = await this.resolveSnippetsPath(args.path);
-        const resolvedPlugin = await this.resolveSnippetPlugin(plugin);
-        this.log(`📥 Pulling snippets from ${url} via ${resolvedPlugin}`);
-        this.log(`📂 From snippet path: ${path}`);
-        this.log(`🔄 Dry run: ${dryRun ? 'yes' : 'no'}`);
-        try {
-            const adapter = getSnippetPlugin(resolvedPlugin);
-            const endpoint = adapter.endpoint(url);
-            const headers = await this.buildAuthHeaders();
-            const remoteList = await got.get(endpoint, { headers }).json();
-            const snippets = remoteList.map((r) => adapter.fromRemote(r));
-            const fs = await import('node:fs/promises');
-            await fs.mkdir(path, { recursive: true });
-            if (dryRun) {
-                this.log(`📝 [DRY RUN] Would pull ${snippets.length} snippets`);
-                this.log(`🔍 Raw API sample:\n${JSON.stringify(remoteList[0], null, 2)}`);
-                return;
-            }
-            let count = 0;
-            let skipped = 0;
-            for (const snippet of snippets) {
-                if (!snippet.name.trim()) {
-                    skipped++;
-                    continue;
-                }
-                const ext = EXTENSIONS[snippet.type];
-                const slug = slugify(snippet.name, { lower: true, strict: true });
-                const base = `${snippet.id}-${slug}`;
-                const filePath = `${path}/${base}.${ext}`;
-                const metaPath = `${path}/${base}.json`;
-                await fs.writeFile(filePath, buildSnippetFile(snippet));
-                await fs.writeFile(metaPath, buildMetaFile(snippet));
-                count++;
-                this.log(`✅ Pulled: ${snippet.name}`);
-            }
-            this.log(`🎉 Successfully pulled ${count} snippet${count === 1 ? '' : 's'} to ${path}`);
-            if (skipped > 0) {
-                this.warn(`${skipped} snippet${skipped === 1 ? '' : 's'} skipped because they have no name`);
+        const path = this.resolveSnippetsPath(args.path);
+        const resolvedPlugin = this.resolveSnippetPlugin(flags.plugin);
+        this.log(`Pulling snippets from ${url} via ${resolvedPlugin}`);
+        this.log(`Snippets path: ${path}`);
+        const adapter = getSnippetPlugin(resolvedPlugin);
+        const remoteList = await this.wp.get(adapter.endpointPath());
+        const snippets = remoteList.map((r) => adapter.fromRemote(r));
+        if (this.dryRun) {
+            this.log(`[dry-run] Would pull ${snippets.length} snippet${snippets.length === 1 ? '' : 's'} to ${path}`);
+            return;
+        }
+        await mkdir(path, { recursive: true });
+        let count = 0;
+        let skipped = 0;
+        for (const snippet of snippets) {
+            if (!snippet.name.trim()) {
+                skipped++;
+                continue;
             }
+            const ext = EXTENSIONS[snippet.type];
+            const slug = slugify(snippet.name, { lower: true, strict: true });
+            const base = `${snippet.id}-${slug}`;
+            await writeFile(join(path, `${base}.${ext}`), buildSnippetFile(snippet));
+            await writeFile(join(path, `${base}.json`), buildMetaFile(snippet));
+            count++;
+            this.log(`  Pulled: ${snippet.name}`);
         }
-        catch (error) {
-            this.error(`❌ Error pulling snippets: ${error.message}`);
+        this.log(`Pulled ${count} snippet${count === 1 ? '' : 's'} to ${path}`);
+        if (skipped > 0) {
+            this.warn(`${skipped} snippet${skipped === 1 ? '' : 's'} skipped because they have no name`);
         }
     }
 }

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

@@ -6,14 +6,14 @@ export default class Push extends PushCommand {
     static description: string;
     static examples: string[];
     static flags: {
-        dryRun: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         plugin: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'dry-run': 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 injectIdIntoMeta;
+    private ensureCanonicalFilename;
     private loadSnippets;
     private pushSnippet;
 }

package/dist/commands/snippet/push.js

@@ -1,59 +1,69 @@
-import { Args, Flags } from '@oclif/core';
-import got from 'got';
+import { Args } from '@oclif/core';
+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 } 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',
+    '.js': 'js',
+    '.php': 'php',
+    '.txt': 'text',
+};
 export default class Push extends PushCommand {
     static args = {
         path: Args.string({ description: 'Path to snippets directory (overrides project config)' }),
     };
-    static description = 'Push snippets to WordPress';
+    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 snippets push',
-        '$ lps snippets push --url http://example.com',
-        '$ lps snippets push --path ./snippets',
-        '$ lps snippets push --plugin wpcode',
+        '$ lps snippet push',
+        '$ lps snippet push --url http://example.com',
+        '$ lps snippet push --path ./snippets',
+        '$ lps snippet push --plugin wpcode',
     ];
     static flags = {
         ...PushCommand.baseFlags,
-        dryRun: Flags.boolean({ char: 'd', description: 'Dry run - show what would happen without making changes' }),
-        plugin: Flags.string({
-            char: 'p',
-            description: 'WordPress snippet plugin to target (overrides loopress.json)',
-            options: ['code-snippets', 'wpcode'],
-        }),
+        ...PushCommand.dryRunFlag,
+        ...snippetPluginFlag,
     };
     async run() {
         const { args, flags } = await this.parse(Push);
-        const { dryRun, 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!');
+        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);
+        let failed = 0;
+        for (const snippet of snippets) {
+            const pushed = await this.pushSnippet(snippet, adapter);
+            if (!pushed)
+                failed++;
         }
-        catch (error) {
-            this.error(error.message);
+        if (failed > 0) {
+            this.error(`${failed} snippet${failed === 1 ? '' : 's'} failed to push.`);
         }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All snippets pushed.');
     }
-    async injectIdIntoMeta(filePath, id) {
-        const fs = await import('node:fs/promises');
-        const metaPath = filePath.replace(/\.[^.]+$/, '.json');
+    // 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 dir = dirname(snippet.path);
+        const ext = extname(snippet.path);
+        const currentBase = basename(snippet.path, ext);
+        const canonicalBase = `${id}-${slugify(name, { lower: true, strict: true })}`;
+        const oldMetaPath = join(dir, `${currentBase}.json`);
         let meta = {};
         try {
-            const existing = await fs.readFile(metaPath, 'utf8');
+            const existing = await readFile(oldMetaPath, 'utf8');
             meta = JSON.parse(existing);
         }
         catch (error) {
@@ -61,70 +71,104 @@ export default class Push extends PushCommand {
                 throw error;
         }
         meta.id = id;
-        await fs.writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+        meta.name = name;
+        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 rename(snippet.path, newPath);
+        await writeFile(newMetaPath, JSON.stringify(meta, null, 2) + '\n');
+        await rm(oldMetaPath, { force: true });
+        this.log(`  Renamed: ${snippet.path} → ${newPath}`);
     }
     async loadSnippets(path) {
-        const fs = await import('node:fs/promises');
         const snippets = [];
-        const SNIPPET_EXTENSIONS = new Set(['.css', '.html', '.js', '.php', '.txt']);
         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,
+                    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)}...`);
-            return;
+    async pushSnippet(snippet, adapter) {
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${snippet.name}`);
+            return true;
         }
+        const endpointPath = adapter.endpointPath();
         try {
-            const endpoint = adapter.endpoint(url);
-            const payload = adapter.toPayload(snippet.name, snippet.code, snippet.path);
+            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}`);
-                return;
+                await this.wp.put(`${endpointPath}/${snippet.id}`, payload);
+                this.log(`  Updated: ${snippet.name} (id: ${snippet.id})`);
+                await this.ensureCanonicalFilename(snippet, snippet.id, snippet.name);
+            }
+            else {
+                const response = await this.wp.post(endpointPath, payload);
+                const created = adapter.fromRemote(response);
+                this.log(`  Created: ${snippet.name} (id: ${created.id})`);
+                await this.ensureCanonicalFilename(snippet, created.id, created.name);
             }
-            this.log(`➕ Creating new snippet: ${snippet.name}`);
-            const response = await got.post(endpoint, { headers, json: payload }).json();
-            const created = adapter.fromRemote(response);
-            await this.injectIdIntoMeta(snippet.path, created.id);
-            this.log(`✅ Created: ${snippet.name} (id: ${created.id})`);
+            return true;
         }
         catch (error) {
-            this.error(`❌ Error pushing snippet ${snippet.name}: ${error.message}`);
+            this.warn(`  Failed to push ${snippet.name}: ${error.message}`);
+            return false;
         }
     }
 }

package/dist/commands/{project/remove-env.d.ts → status.d.ts}

@@ -1,6 +1,8 @@
 import { Command } from '@oclif/core';
-export default class RemoveEnv extends Command {
+export default class Status extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    private reportActiveProject;
+    private reportPinnedProject;
 }

package/dist/commands/status.js

@@ -0,0 +1,66 @@
+import { Command, ux } from '@oclif/core';
+import { configManager } from '../config/project-config.manager.js';
+import { readLocalConfig } from '../utils/loopress-config.js';
+const c = ux.colorize;
+export default class Status extends Command {
+    static description = 'Show which WordPress project and environment commands will target';
+    static examples = ['$ lps status'];
+    async run() {
+        await this.parse(Status);
+        const localConfig = await readLocalConfig();
+        if (localConfig.projectId) {
+            this.reportPinnedProject(localConfig.projectId);
+            return;
+        }
+        this.reportActiveProject();
+    }
+    reportActiveProject() {
+        const env = configManager.getCurrentEnv();
+        if (!env) {
+            this.log('No project configured. Run `lps project config` first.');
+            return;
+        }
+        const project = configManager.getCurrentProject();
+        if (!project) {
+            this.log('No project configured. Run `lps project config` first.');
+            return;
+        }
+        this.log(`Project:  ${project.name} (${env.name})`);
+        this.log(`URL:      ${env.url}`);
+    }
+    reportPinnedProject(projectId) {
+        const project = configManager.getProject(projectId);
+        if (!project) {
+            this.log(`loopress.json pins project "${projectId}", but it no longer exists.`);
+            this.log('Run `lps project config` to configure it.');
+            return;
+        }
+        const envNames = Object.keys(project.environments);
+        if (envNames.length === 0) {
+            this.log(`Project:  ${project.name}`);
+            this.log('No environments configured for this project. Run `lps project config` to add one.');
+            return;
+        }
+        if (envNames.length === 1) {
+            const env = project.environments[envNames[0]];
+            this.log(`Project:  ${project.name} (${env.name})`);
+            this.log(`URL:      ${env.url}`);
+            return;
+        }
+        const current = configManager.getCurrentProject();
+        const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
+        if (!currentEnv) {
+            this.log(`Project:  ${project.name} ${c('yellow', '(ambiguous)')}`);
+            this.log(`Environments: ${envNames.join(', ')}`);
+            this.log('');
+            this.warn(`"${project.name}" has multiple environments and isn't the globally active project.`);
+            this.log('Run `lps project switch` to pick one before running commands here.');
+            if (current) {
+                this.log(`(Globally active project right now: "${current.name}")`);
+            }
+            return;
+        }
+        this.log(`Project:  ${project.name} (${currentEnv.name})`);
+        this.log(`URL:      ${currentEnv.url}`);
+    }
+}

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,28 +1,33 @@
-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;
     getCurrentEnv(): EnvironmentConfig | null;
-    getCurrentProject(): null | ProjectConfig;
-    getEnvironment(projectName: string, envName: string): EnvironmentConfig | null;
-    getProject(name: string): null | ProjectConfig;
-    listEnvironments(projectName: string): Array<EnvironmentConfig & {
+    getCurrentProject(): null | (ProjectConfig & {
+        id: string;
+    });
+    getEnvironment(projectId: string, envName: string): EnvironmentConfig | null;
+    getProject(id: string): null | ProjectConfig;
+    listEnvironments(projectId: string): Array<EnvironmentConfig & {
         isCurrent: boolean;
     }>;
     listProjects(): Array<ProjectConfig & {
+        id: string;
         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;
+    removeEnvironment(projectId: string, envName: string): void;
+    removeProject(id: string): void;
+    setCurrent(projectId: string, envName: string): void;
+    setEnvironment(projectId: string, envName: string, env: EnvironmentConfig): void;
+    setProject(id: string, project: ProjectConfig): void;
     writeConfig(config: LoopressConfig): void;
+    private isProjectConfig;
+    private sanitizeConfig;
+    private sanitizeCurrentProject;
+    private sanitizeProjects;
 }
 export declare const configManager: ProjectConfigManager;