@flui-cloud/cli 0.0.1

package/lib/cli/src/lib/ca-utils.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCAPublicKey = getCAPublicKey;
+exports.isCAConfigured = isCAConfigured;
+exports.getCAPath = getCAPath;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const FLUI_DIR = path.join(os.homedir(), '.flui');
+const CA_DIR = path.join(FLUI_DIR, 'ca');
+const CA_PUBLIC_KEY_PATH = path.join(CA_DIR, 'ca-key.pub');
+/**
+ * Get CA public key for SSH certificate authentication
+ * @returns CA public key content or null if not found
+ */
+function getCAPublicKey() {
+    if (!fs.existsSync(CA_PUBLIC_KEY_PATH)) {
+        return null;
+    }
+    try {
+        return fs.readFileSync(CA_PUBLIC_KEY_PATH, 'utf-8').trim();
+    }
+    catch (error) {
+        console.warn(`Failed to read CA public key: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Check if CA certificate system is configured
+ */
+function isCAConfigured() {
+    return fs.existsSync(CA_PUBLIC_KEY_PATH);
+}
+/**
+ * Get CA configuration path for debugging
+ */
+function getCAPath() {
+    return CA_PUBLIC_KEY_PATH;
+}

package/lib/cli/src/lib/cli-credential-provider.service.d.ts

@@ -0,0 +1,31 @@
+import { ICredentialProvider } from '../../../src/modules/providers/interfaces/credential-provider.interface';
+import { CloudProvider } from '../../../src/modules/providers/enums/cloud-provider.enum';
+import { BearerTokenDto } from '../../../src/modules/access/dto/bearer-token.dto';
+/**
+ * CLI-specific credential provider that uses file-based ConfigStorage
+ * instead of TypeORM repositories.
+ *
+ * This allows the CLI to work without a database connection while
+ * maintaining compatibility with the existing provider architecture.
+ */
+export declare class CliCredentialProviderService implements ICredentialProvider {
+    private readonly configStorage;
+    constructor();
+    /**
+     * Get active API token for a cloud provider from CLI config file
+     */
+    getActiveApiToken(provider: CloudProvider): Promise<string>;
+    /**
+     * Get the access/secret key pair for providers that authenticate with two values
+     * (e.g. Scaleway IAM API keys).
+     */
+    getActiveAccessKeyPair(provider: CloudProvider): Promise<{
+        accessKey: string;
+        secretKey: string;
+    }>;
+    getActiveBearerToken(provider: CloudProvider): Promise<BearerTokenDto>;
+    /**
+     * Map CloudProvider enum to lowercase string for config storage
+     */
+    private mapProviderEnumToString;
+}

package/lib/cli/src/lib/cli-credential-provider.service.js

@@ -0,0 +1,86 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliCredentialProviderService = void 0;
+const common_1 = require("@nestjs/common");
+const cloud_provider_enum_1 = require("../../../src/modules/providers/enums/cloud-provider.enum");
+const config_storage_1 = require("./config-storage");
+/**
+ * CLI-specific credential provider that uses file-based ConfigStorage
+ * instead of TypeORM repositories.
+ *
+ * This allows the CLI to work without a database connection while
+ * maintaining compatibility with the existing provider architecture.
+ */
+let CliCredentialProviderService = class CliCredentialProviderService {
+    constructor() {
+        this.configStorage = new config_storage_1.ConfigStorage();
+    }
+    /**
+     * Get active API token for a cloud provider from CLI config file
+     */
+    async getActiveApiToken(provider) {
+        const providerName = this.mapProviderEnumToString(provider);
+        // Scaleway authenticates HTTP calls with the Secret Key (sent as
+        // X-Auth-Token). Most code paths in the provider services treat this as
+        // a single "API token" string, so return the secretKey here while keeping
+        // the access/secret pair available via getActiveAccessKeyPair().
+        if (provider === cloud_provider_enum_1.CloudProvider.SCALEWAY) {
+            const creds = this.configStorage.getCredentials(providerName);
+            if (!creds?.secretKey) {
+                throw new common_1.NotFoundException(`No credentials configured for ${providerName}. ` +
+                    `Run: flui config set ${providerName}`);
+            }
+            return creds.secretKey;
+        }
+        const token = this.configStorage.getToken(providerName);
+        if (!token) {
+            throw new common_1.NotFoundException(`No API token configured for ${providerName}. ` +
+                `Run: flui config set ${providerName} YOUR_TOKEN`);
+        }
+        return token;
+    }
+    /**
+     * Get the access/secret key pair for providers that authenticate with two values
+     * (e.g. Scaleway IAM API keys).
+     */
+    async getActiveAccessKeyPair(provider) {
+        const providerName = this.mapProviderEnumToString(provider);
+        const creds = this.configStorage.getCredentials(providerName);
+        if (!creds?.accessKey || !creds?.secretKey) {
+            throw new common_1.NotFoundException(`No credentials configured for ${providerName}. ` +
+                `Run: flui config set ${providerName}`);
+        }
+        return { accessKey: creds.accessKey, secretKey: creds.secretKey };
+    }
+    async getActiveBearerToken(provider) {
+        throw new Error('Bearer token authentication is not supported in CLI. ' +
+            'Please use API token authentication instead.');
+    }
+    /**
+     * Map CloudProvider enum to lowercase string for config storage
+     */
+    mapProviderEnumToString(provider) {
+        switch (provider) {
+            case cloud_provider_enum_1.CloudProvider.HETZNER:
+                return 'hetzner';
+            case cloud_provider_enum_1.CloudProvider.SCALEWAY:
+                return 'scaleway';
+            default:
+                throw new Error(`Unsupported provider: ${provider}`);
+        }
+    }
+};
+exports.CliCredentialProviderService = CliCredentialProviderService;
+exports.CliCredentialProviderService = CliCredentialProviderService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], CliCredentialProviderService);

package/lib/cli/src/lib/config-storage.d.ts

@@ -0,0 +1,128 @@
+export declare class ConfigStorage {
+    private readonly encryptionKey;
+    private readonly configDir;
+    private readonly configFile;
+    private readonly encryptionKeyFile;
+    constructor(profile?: string);
+    /**
+     * Ensure profile directory exists
+     */
+    private ensureConfigDir;
+    /**
+     * Get or create encryption key for AES-256-GCM
+     */
+    private getOrCreateEncryptionKey;
+    /**
+     * Encrypt string using AES-256-GCM
+     */
+    private encrypt;
+    /**
+     * Decrypt string using AES-256-GCM
+     */
+    private decrypt;
+    /**
+     * Read config file (create if doesn't exist)
+     */
+    private readConfig;
+    /**
+     * Write config file
+     */
+    private writeConfig;
+    /**
+     * Save encrypted API token for provider
+     */
+    saveToken(provider: string, token: string): void;
+    /**
+     * Get decrypted API token for provider
+     */
+    getToken(provider: string): string | null;
+    /**
+     * Get token metadata (without decrypting)
+     */
+    getTokenMetadata(provider: string): {
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+    /**
+     * Remove API token for provider
+     */
+    removeToken(provider: string): void;
+    /**
+     * Check if token exists for provider
+     */
+    hasToken(provider: string): boolean;
+    /**
+     * Save encrypted credentials for provider
+     */
+    saveCredentials(provider: string, credentials: any): void;
+    /**
+     * Get decrypted credentials for provider
+     */
+    getCredentials(provider: string): any | null;
+    hasCredentials(provider: string): boolean;
+    removeCredentials(provider: string): void;
+    /**
+     * List all configured providers
+     */
+    listProviders(): string[];
+    /**
+     * Get config file path (for debugging)
+     */
+    getConfigPath(): string;
+    /**
+     * Save API URL
+     */
+    saveApiUrl(url: string): void;
+    /**
+     * Returns the ISO timestamp of the last apiUrl update, or null if never tracked.
+     */
+    getApiUrlUpdatedAt(): string | null;
+    /**
+     * Get API URL.
+     * Resolution order:
+     *   1. Saved value in this profile's config.json
+     *   2. FLUI_API_URL env var
+     *   3. Derived from clusters.json (master IP + nip token)
+     * Returns null when no source provides a value — callers must decide whether
+     * to error out (e.g. command needs API access) or just skip.
+     */
+    getApiUrl(): string | null;
+    /**
+     * Same as getApiUrl but throws a CLI-friendly error when no URL is configured.
+     * Use this from commands that cannot work without an API endpoint.
+     */
+    getApiUrlOrThrow(): string;
+    /**
+     * Remove API URL from config
+     */
+    removeApiUrl(): void;
+    /**
+     * Save encrypted API key for CLI M2M access
+     */
+    setApiKey(key: string): void;
+    /**
+     * Get decrypted API key for CLI M2M access
+     * Falls back to FLUI_API_KEY environment variable
+     */
+    getApiKey(): string | null;
+    /**
+     * Read a non-secret preference from the active profile. Returns null when unset.
+     * Preferences live in a dedicated namespace so they never collide with tokens/apiKey/metadata.
+     */
+    getPreference<T = unknown>(key: string): T | null;
+    /**
+     * Persist a non-secret preference under the active profile.
+     * Use null/undefined to clear via `removePreference` instead.
+     */
+    setPreference(key: string, value: unknown): void;
+    removePreference(key: string): void;
+    getAllPreferences(): Record<string, unknown>;
+    getAcmeIssuances(): AcmeIssuance[];
+    recordAcmeIssuance(entry: Omit<AcmeIssuance, 'issuedAt'>): void;
+    countAcmeIssuances(domains: string, server: 'production' | 'staging'): number;
+}
+export interface AcmeIssuance {
+    domains: string;
+    server: 'production' | 'staging';
+    issuedAt: string;
+}

package/lib/cli/src/lib/config-storage.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigStorage = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const profile_manager_1 = require("./profile-manager");
+const nip_base_domain_util_1 = require("./nip-base-domain.util");
+class ConfigStorage {
+    constructor(profile) {
+        this.configDir = profile_manager_1.ProfileManager.getProfileDir(profile);
+        this.configFile = (0, node_path_1.join)(this.configDir, 'config.json');
+        this.encryptionKeyFile = (0, node_path_1.join)(this.configDir, '.key');
+        this.ensureConfigDir();
+        this.encryptionKey = this.getOrCreateEncryptionKey();
+    }
+    /**
+     * Ensure profile directory exists
+     */
+    ensureConfigDir() {
+        if (!(0, node_fs_1.existsSync)(this.configDir)) {
+            (0, node_fs_1.mkdirSync)(this.configDir, { recursive: true, mode: 0o700 });
+        }
+    }
+    /**
+     * Get or create encryption key for AES-256-GCM
+     */
+    getOrCreateEncryptionKey() {
+        if ((0, node_fs_1.existsSync)(this.encryptionKeyFile)) {
+            return (0, node_fs_1.readFileSync)(this.encryptionKeyFile);
+        }
+        // Generate new 32-byte key for AES-256
+        const key = (0, node_crypto_1.randomBytes)(32);
+        (0, node_fs_1.writeFileSync)(this.encryptionKeyFile, key, { mode: 0o600 });
+        return key;
+    }
+    /**
+     * Encrypt string using AES-256-GCM
+     */
+    encrypt(plaintext) {
+        const iv = (0, node_crypto_1.randomBytes)(16);
+        const cipher = (0, node_crypto_1.createCipheriv)('aes-256-gcm', this.encryptionKey, iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        const authTag = cipher.getAuthTag();
+        // Format: iv:authTag:ciphertext
+        return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+    }
+    /**
+     * Decrypt string using AES-256-GCM
+     */
+    decrypt(ciphertext) {
+        const parts = ciphertext.split(':');
+        if (parts.length !== 3) {
+            throw new Error('Invalid ciphertext format');
+        }
+        const [ivHex, authTagHex, encryptedHex] = parts;
+        const iv = Buffer.from(ivHex, 'hex');
+        const authTag = Buffer.from(authTagHex, 'hex');
+        const decipher = (0, node_crypto_1.createDecipheriv)('aes-256-gcm', this.encryptionKey, iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encryptedHex, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    /**
+     * Read config file (create if doesn't exist)
+     */
+    readConfig() {
+        if (!(0, node_fs_1.existsSync)(this.configFile)) {
+            return {
+                tokens: {},
+                credentials: {},
+                metadata: {
+                    version: '1.0.0',
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                },
+            };
+        }
+        try {
+            const content = (0, node_fs_1.readFileSync)(this.configFile, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to read config file: ${error.message}`);
+        }
+    }
+    /**
+     * Write config file
+     */
+    writeConfig(config) {
+        config.metadata.updatedAt = new Date().toISOString();
+        (0, node_fs_1.writeFileSync)(this.configFile, JSON.stringify(config, null, 2), {
+            mode: 0o600,
+        });
+    }
+    /**
+     * Save encrypted API token for provider
+     */
+    saveToken(provider, token) {
+        const config = this.readConfig();
+        const now = new Date().toISOString();
+        const existing = config.tokens[provider];
+        config.tokens[provider] = {
+            encrypted: this.encrypt(token),
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+        };
+        this.writeConfig(config);
+    }
+    /**
+     * Get decrypted API token for provider
+     */
+    getToken(provider) {
+        const config = this.readConfig();
+        const tokenData = config.tokens[provider];
+        if (!tokenData) {
+            return null;
+        }
+        try {
+            return this.decrypt(tokenData.encrypted);
+        }
+        catch (error) {
+            throw new Error(`Failed to decrypt token for ${provider}: ${error.message}`);
+        }
+    }
+    /**
+     * Get token metadata (without decrypting)
+     */
+    getTokenMetadata(provider) {
+        const config = this.readConfig();
+        const tokenData = config.tokens[provider];
+        if (!tokenData) {
+            return null;
+        }
+        return {
+            createdAt: tokenData.createdAt,
+            updatedAt: tokenData.updatedAt,
+        };
+    }
+    /**
+     * Remove API token for provider
+     */
+    removeToken(provider) {
+        const config = this.readConfig();
+        delete config.tokens[provider];
+        this.writeConfig(config);
+    }
+    /**
+     * Check if token exists for provider
+     */
+    hasToken(provider) {
+        const config = this.readConfig();
+        return provider in config.tokens;
+    }
+    /**
+     * Save encrypted credentials for provider
+     */
+    saveCredentials(provider, credentials) {
+        const config = this.readConfig();
+        config.credentials[provider] = this.encrypt(JSON.stringify(credentials));
+        this.writeConfig(config);
+    }
+    /**
+     * Get decrypted credentials for provider
+     */
+    getCredentials(provider) {
+        const config = this.readConfig();
+        const encryptedCredentials = config.credentials[provider];
+        if (!encryptedCredentials) {
+            return null;
+        }
+        try {
+            const decrypted = this.decrypt(encryptedCredentials);
+            return JSON.parse(decrypted);
+        }
+        catch (error) {
+            throw new Error(`Failed to decrypt credentials for ${provider}: ${error.message}`);
+        }
+    }
+    hasCredentials(provider) {
+        const config = this.readConfig();
+        return provider in config.credentials;
+    }
+    removeCredentials(provider) {
+        const config = this.readConfig();
+        delete config.credentials[provider];
+        this.writeConfig(config);
+    }
+    /**
+     * List all configured providers
+     */
+    listProviders() {
+        const config = this.readConfig();
+        const tokenProviders = Object.keys(config.tokens);
+        const credentialProviders = Object.keys(config.credentials);
+        return [...new Set([...tokenProviders, ...credentialProviders])];
+    }
+    /**
+     * Get config file path (for debugging)
+     */
+    getConfigPath() {
+        return this.configFile;
+    }
+    /**
+     * Save API URL
+     */
+    saveApiUrl(url) {
+        const config = this.readConfig();
+        config.apiUrl = url;
+        config.metadata.apiUrlUpdatedAt = new Date().toISOString();
+        this.writeConfig(config);
+    }
+    /**
+     * Returns the ISO timestamp of the last apiUrl update, or null if never tracked.
+     */
+    getApiUrlUpdatedAt() {
+        const config = this.readConfig();
+        return config.metadata.apiUrlUpdatedAt ?? null;
+    }
+    /**
+     * Get API URL.
+     * Resolution order:
+     *   1. Saved value in this profile's config.json
+     *   2. FLUI_API_URL env var
+     *   3. Derived from clusters.json (master IP + nip token)
+     * Returns null when no source provides a value — callers must decide whether
+     * to error out (e.g. command needs API access) or just skip.
+     */
+    getApiUrl() {
+        const config = this.readConfig();
+        if (config.apiUrl) {
+            return config.apiUrl;
+        }
+        if (process.env.FLUI_API_URL) {
+            return process.env.FLUI_API_URL;
+        }
+        try {
+            const profileDir = profile_manager_1.ProfileManager.getProfileDir();
+            const clustersPath = (0, node_path_1.join)(profileDir, 'clusters.json');
+            if ((0, node_fs_1.existsSync)(clustersPath)) {
+                const clusters = JSON.parse((0, node_fs_1.readFileSync)(clustersPath, 'utf-8'));
+                const cluster = Array.isArray(clusters) ? clusters[0] : null;
+                if (cluster?.masterIpAddress) {
+                    const base = (0, nip_base_domain_util_1.buildNipBaseDomain)(cluster.masterIpAddress, cluster.nipHostnameToken);
+                    return `https://api.${base}/api/v1`;
+                }
+            }
+        }
+        catch {
+            // ignore read errors
+        }
+        return null;
+    }
+    /**
+     * Same as getApiUrl but throws a CLI-friendly error when no URL is configured.
+     * Use this from commands that cannot work without an API endpoint.
+     */
+    getApiUrlOrThrow() {
+        const url = this.getApiUrl();
+        if (!url) {
+            throw new Error('API URL is not configured for this context.\n' +
+                '  • Run `flui env create` to provision a cluster (URL is auto-derived).\n' +
+                '  • Or set it manually: `flui config set api-url https://api.example.com/api/v1`.');
+        }
+        return url;
+    }
+    /**
+     * Remove API URL from config
+     */
+    removeApiUrl() {
+        const config = this.readConfig();
+        delete config.apiUrl;
+        this.writeConfig(config);
+    }
+    /**
+     * Save encrypted API key for CLI M2M access
+     */
+    setApiKey(key) {
+        const config = this.readConfig();
+        config.apiKey = this.encrypt(key);
+        this.writeConfig(config);
+    }
+    /**
+     * Get decrypted API key for CLI M2M access
+     * Falls back to FLUI_API_KEY environment variable
+     */
+    getApiKey() {
+        if (process.env.FLUI_API_KEY) {
+            return process.env.FLUI_API_KEY;
+        }
+        const config = this.readConfig();
+        if (!config.apiKey)
+            return null;
+        try {
+            return this.decrypt(config.apiKey);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Read a non-secret preference from the active profile. Returns null when unset.
+     * Preferences live in a dedicated namespace so they never collide with tokens/apiKey/metadata.
+     */
+    getPreference(key) {
+        const config = this.readConfig();
+        const value = config.preferences?.[key];
+        return value === undefined ? null : value;
+    }
+    /**
+     * Persist a non-secret preference under the active profile.
+     * Use null/undefined to clear via `removePreference` instead.
+     */
+    setPreference(key, value) {
+        const config = this.readConfig();
+        if (!config.preferences)
+            config.preferences = {};
+        config.preferences[key] = value;
+        this.writeConfig(config);
+    }
+    removePreference(key) {
+        const config = this.readConfig();
+        if (!config.preferences)
+            return;
+        delete config.preferences[key];
+        this.writeConfig(config);
+    }
+    getAllPreferences() {
+        return { ...this.readConfig().preferences };
+    }
+    // ACME issuance tracking (Let's Encrypt rate-limit awareness)
+    // Window matches LE: 5 certs per identical domain set per 168h.
+    getAcmeIssuances() {
+        const all = (this.getPreference('acmeIssuances') ?? []).filter((i) => Date.now() - new Date(i.issuedAt).getTime() < 168 * 3600 * 1000);
+        this.setPreference('acmeIssuances', all);
+        return all;
+    }
+    recordAcmeIssuance(entry) {
+        const all = this.getAcmeIssuances();
+        all.push({ ...entry, issuedAt: new Date().toISOString() });
+        this.setPreference('acmeIssuances', all);
+    }
+    countAcmeIssuances(domains, server) {
+        return this.getAcmeIssuances().filter((i) => i.domains === domains && i.server === server).length;
+    }
+}
+exports.ConfigStorage = ConfigStorage;

package/lib/cli/src/lib/config.d.ts

@@ -0,0 +1,23 @@
+import { Config } from '../types';
+/**
+ * Read configuration from ~/.flui/config.json
+ * @returns Configuration object
+ */
+export declare function getConfig(): Config;
+/**
+ * Write configuration to ~/.flui/config.json
+ * @param key Configuration key
+ * @param value Configuration value
+ */
+export declare function setConfig(key: string, value: string): void;
+/**
+ * Get Hetzner token from config
+ * @returns Hetzner API token
+ * @throws Error if token is not configured
+ */
+export declare function getToken(): string;
+/**
+ * Get config file path
+ * @returns Path to config file
+ */
+export declare function getConfigPath(): string;