@super-protocol/sp-cli 0.0.6 → 0.0.8

package/dist/hooks/finally/unlock-config.js

@@ -0,0 +1,5 @@
+import { releaseCliInstanceLock } from '../../lib/cli-instance-lock.js';
+const hook = async () => {
+    await releaseCliInstanceLock();
+};
+export default hook;

package/dist/hooks/init/init-container.d.ts

@@ -1,3 +1,3 @@
-import { Hook } from '@oclif/core';
+import type { Hook } from '@oclif/core';
 declare const hook: Hook<'init'>;
 export default hook;

package/dist/hooks/init/init-container.js

@@ -1,6 +1,5 @@
 import { AppContainer } from '../../lib/container.js';
-const hook = async function (opts) {
-    AppContainer
-        .initialize(process.cwd(), opts.config);
+const hook = async (opts) => {
+    AppContainer.initialize(process.cwd(), opts.config);
 };
 export default hook;

package/dist/hooks/init/lock-config.d.ts

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

package/dist/hooks/init/lock-config.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { acquireCliInstanceLock } from '../../lib/cli-instance-lock.js';
+import { ConfigFileManager } from '../../managers/config-file-manager.js';
+const hook = async (opts) => {
+    const { context, config } = opts;
+    const lockFile = path.join(config.configDir, ConfigFileManager.CONFIG_FILE);
+    mkdirSync(config.configDir, { recursive: true });
+    try {
+        await acquireCliInstanceLock(lockFile);
+    }
+    catch (error) {
+        if (context) {
+            context.error(error, { exit: 1 });
+        }
+        throw error;
+    }
+};
+export default hook;

package/dist/hooks/prerun/auth.d.ts

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

package/dist/hooks/prerun/auth.js

@@ -0,0 +1,70 @@
+import { BaseCommand } from '../../commands/base.js';
+import { AppContainer } from '../../lib/container.js';
+import logger from '../../logger.js';
+import { AuthService } from '../../services/auth.service.js';
+const isBaseCommandClass = (commandClass) => commandClass.prototype instanceof BaseCommand;
+const getConfigFlag = (commandClass, argv) => {
+    if (!isBaseCommandClass(commandClass)) {
+        return undefined;
+    }
+    //Fix Parser.parse throws error Nonexistent flag we dont have the way to ignore it
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        if (token === '--config') {
+            const value = argv[index + 1];
+            return value && !value.startsWith('-') ? value : undefined;
+        }
+        if (token.startsWith('--config=')) {
+            const value = token.slice('--config='.length);
+            return value || undefined;
+        }
+    }
+    return undefined;
+};
+const hook = async (opts) => {
+    const { Command, config, context } = opts;
+    const commandId = Command.id;
+    const CommandClass = Command;
+    if (CommandClass.authenticate === false) {
+        return;
+    }
+    const pinoLogger = logger.getPino();
+    pinoLogger.info('Prerun hook auth called');
+    try {
+        const configFile = getConfigFlag(CommandClass, opts.argv ?? []);
+        const container = configFile
+            ? AppContainer.container.setupRuntimeConfig({ configFile })
+            : AppContainer.container;
+        await container
+            .initConfigFileManager()
+            .initConfigManager()
+            .initAccountManager()
+            .initProviderClient({ enableAuth: false, enableCookies: true })
+            .build();
+        const { configManager, accountManager, providerClient } = container;
+        const credentials = await configManager.get('auth');
+        if (!credentials?.accessKey) {
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                context.error('Authorization not found. Please run: sp account login', { exit: 1 });
+            }
+            const args = configFile ? ['--config', configFile] : [];
+            pinoLogger.info({ commandId }, 'Authorization not found, redirecting to account:login');
+            await config.runCommand('account:login', args);
+        }
+        const authService = new AuthService(accountManager, configManager, providerClient, pinoLogger);
+        await authService.auth();
+        pinoLogger.debug({ commandId }, 'Authentication successful');
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('not initialized')) {
+            pinoLogger.debug({ commandId, err: error }, 'Container not initialized, skipping auth');
+            return;
+        }
+        pinoLogger.error({ commandId, err: error }, 'Authentication failed in prerun hook');
+        throw error;
+    }
+};
+export default hook;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { Interfaces, run as oclifRun } from '@oclif/core';
+import { type Interfaces, run as oclifRun } from '@oclif/core';
 export declare const run: (argv: string[], loadOptions?: Interfaces.LoadOptions | URL) => ReturnType<typeof oclifRun>;

package/dist/index.js

@@ -1,5 +1,5 @@
-import { run as oclifRun } from '@oclif/core';
 import { fileURLToPath } from 'node:url';
+import { run as oclifRun } from '@oclif/core';
 import logger from './logger.js';
 const normalizeLoadOptions = (loadOptions) => {
     if (!loadOptions) {

package/dist/interfaces/account-manager.interface.d.ts

@@ -1,4 +1,4 @@
-import { IManager } from './manager.interface.js';
+import type { IManager } from './manager.interface.js';
 export interface IAccountManager extends IManager {
     createSign(nonce: string): Promise<string>;
     getAddress(): string;

package/dist/interfaces/config-manager.interface.d.ts

@@ -1,5 +1,5 @@
-import { CliConfig } from '../config/config.schema.js';
-import { IManager } from './manager.interface.js';
+import type { CliConfig } from '../config/config.schema.js';
+import type { IManager } from './manager.interface.js';
 export interface IConfigManager extends IManager {
     get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
     load(): Promise<CliConfig>;

package/dist/lib/cli-instance-lock.d.ts

@@ -0,0 +1,2 @@
+export declare const acquireCliInstanceLock: (lockTarget: string) => Promise<void>;
+export declare const releaseCliInstanceLock: () => Promise<void>;

package/dist/lib/cli-instance-lock.js

@@ -0,0 +1,37 @@
+import { lock } from 'proper-lockfile';
+let release;
+let locked = false;
+const isLockHeldError = (error) => Boolean(error &&
+    typeof error === 'object' &&
+    'code' in error &&
+    error.code === 'ELOCKED');
+export const acquireCliInstanceLock = async (lockTarget) => {
+    if (locked) {
+        return;
+    }
+    try {
+        release = await lock(lockTarget, {
+            realpath: false,
+            retries: 0,
+            stale: 30_000,
+        });
+        locked = true;
+    }
+    catch (error) {
+        if (isLockHeldError(error)) {
+            const lockHeldError = Object.assign(new Error('Another instance of spcli is already running.'), { code: 'ELOCKED' });
+            throw lockHeldError;
+        }
+        throw error;
+    }
+};
+export const releaseCliInstanceLock = async () => {
+    if (!release) {
+        locked = false;
+        return;
+    }
+    const currentRelease = release;
+    release = undefined;
+    locked = false;
+    await currentRelease();
+};

package/dist/lib/container.d.ts

@@ -1,5 +1,5 @@
-import { Config } from '@oclif/core';
-import { ProviderClient } from '@super-protocol/provider-client';
+import type { Config } from '@oclif/core';
+import { type ProviderClient } from '@super-protocol/provider-client';
 import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
 interface RuntimeConfig {
     configFile?: string;
@@ -12,9 +12,10 @@ export declare class AppContainer {
     private _configFileManager?;
     private _configManager?;
     private _providerClient?;
-    private initPromises;
+    private providerClientOptions?;
     private readonly initQueue;
     private logger;
+    private providerClientInitToken;
     private runtimeConfigFile?;
     private constructor();
     static initialize(currentDir: string, config: Config): AppContainer;
@@ -28,12 +29,13 @@ export declare class AppContainer {
     initBlockchainConnector(): this;
     initConfigFileManager(rebuild?: boolean): this;
     initConfigManager(rebuild?: boolean): this;
-    initProviderClient({ enableAuth, enableCookies, rebuild }?: {
+    initProviderClient({ enableAuth, enableCookies, rebuild, }?: {
         enableAuth?: boolean;
         enableCookies?: boolean;
         rebuild?: boolean;
     }): this;
     setupRuntimeConfig(config: RuntimeConfig): this;
+    private getProviderClientForBootstrap;
     private queueInit;
     private waitFor;
 }

package/dist/lib/container.js

@@ -1,9 +1,9 @@
+import path from 'node:path';
 import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
 import { BlockchainConnector } from '@super-protocol/sdk-js';
-import path from 'node:path';
 import { PROVIDER_URL } from '../constants.js';
 import logger from '../logger.js';
-import { AccountManager, ConfigFileManager, ConfigManager, } from '../managers/index.js';
+import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
 import { createAuthMiddleware } from '../middlewares/auth-middleware.js';
 import { createCookieMiddleware } from '../middlewares/cookies-middleware.js';
 export class AppContainer {
@@ -14,9 +14,10 @@ export class AppContainer {
     _configFileManager;
     _configManager;
     _providerClient;
-    initPromises = [];
+    providerClientOptions;
     initQueue = new Map();
     logger;
+    providerClientInitToken = 0;
     runtimeConfigFile;
     constructor(cwdDir, oclifConfig) {
         this.cwdDir = cwdDir;
@@ -60,16 +61,19 @@ export class AppContainer {
         return this._providerClient;
     }
     async build() {
-        await Promise.all(this.initPromises);
+        await Promise.all(this.initQueue.values());
         return this;
     }
     initAccountManager(rebuild = true) {
         this.initConfigManager(rebuild);
         return this.queueInit('accountManager', async () => {
-            await this.waitFor('configManager');
-            if (this._accountManager) {
+            await this.waitFor('configManager', { required: true });
+            if (this._accountManager && !rebuild) {
                 return;
             }
+            if (rebuild) {
+                this._accountManager = undefined;
+            }
             this.logger.info('Initializing account manager');
             const accountManager = new AccountManager(this.configManager, this.logger);
             await accountManager.init();
@@ -79,11 +83,11 @@ export class AppContainer {
     initBlockchainConnector() {
         this.initConfigManager();
         return this.queueInit('blockchainConnector', async () => {
-            await this.waitFor('configManager');
+            await this.waitFor('configManager', { required: true });
             let blockchainConfig = await this.configManager.get('blockchain');
             if (!blockchainConfig) {
-                await this.waitFor('providerClient');
-                const { data, error } = await this.providerClient.GET('/api/config');
+                const client = await this.getProviderClientForBootstrap();
+                const { data, error } = await client.GET('/api/config');
                 if (error || !data) {
                     throw new Error('Could not get configuration from provider');
                 }
@@ -99,9 +103,12 @@ export class AppContainer {
     }
     initConfigFileManager(rebuild = false) {
         return this.queueInit('configFileManager', async () => {
-            if (this._configFileManager) {
+            if (this._configFileManager && !rebuild) {
                 return;
             }
+            if (rebuild) {
+                this._configFileManager = undefined;
+            }
             const configFileManager = new ConfigFileManager(this.oclifConfig.configDir, this.logger, {
                 runtimeConfigFile: this.runtimeConfigFile,
             });
@@ -112,10 +119,13 @@ export class AppContainer {
     initConfigManager(rebuild = false) {
         this.initConfigFileManager(rebuild);
         return this.queueInit('configManager', async () => {
-            await this.waitFor('configFileManager');
-            if (this._configManager) {
+            await this.waitFor('configFileManager', { required: true });
+            if (this._configManager && !rebuild) {
                 return;
             }
+            if (rebuild) {
+                this._configManager = undefined;
+            }
             const configFilePath = await this.configFileManager.getCurrentConfigPath();
             if (!configFilePath) {
                 throw new Error('Config file not found');
@@ -126,14 +136,30 @@ export class AppContainer {
             this._configManager = configManager;
         }, rebuild);
     }
-    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false } = {}) {
+    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false, } = {}) {
         this.initConfigManager();
+        const options = { enableAuth, enableCookies };
+        const optionsChanged = this.providerClientOptions &&
+            (this.providerClientOptions.enableAuth !== options.enableAuth ||
+                this.providerClientOptions.enableCookies !== options.enableCookies);
+        if (optionsChanged) {
+            rebuild = true;
+            this.logger.debug({ newOptions: options, oldOptions: this.providerClientOptions }, 'Provider client options changed, rebuilding');
+        }
+        const shouldSchedule = rebuild || !this.initQueue.has('providerClient');
+        const initToken = shouldSchedule
+            ? ++this.providerClientInitToken
+            : this.providerClientInitToken;
         return this.queueInit('providerClient', async () => {
             if (this._providerClient && !rebuild) {
                 return;
             }
-            await this.waitFor('configManager');
-            const providerUrl = await this.configManager.get('providerUrl') || PROVIDER_URL;
+            if (rebuild && this._providerClient) {
+                this.logger.debug('Clearing existing provider client for rebuild');
+                this._providerClient = undefined;
+            }
+            await this.waitFor('configManager', { required: true });
+            const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
             this.logger.info('Initializing provider client');
             const providerClient = createProviderClient({
                 baseUrl: providerUrl,
@@ -150,28 +176,28 @@ export class AppContainer {
                 const authMiddleware = await createAuthMiddleware(this.configManager, providerClient, this.logger);
                 providerClient.use(authMiddleware);
             }
-            providerClient.use({
-                onRequest: async ({ request }) => {
-                    const req = request.clone();
-                    const readBody = await req.body?.getReader().read();
-                    let body;
-                    if (readBody && readBody.value) {
-                        body = Buffer.from(readBody.value).toString('utf8');
-                    }
-                    this.logger.debug({
-                        body,
-                        token: req.headers.get('Authorization'),
-                        url: req.url,
-                    }, 'Requesting');
-                },
-            });
+            if (process.env.SP_CLI_DEBUG_REQUESTS === '1') {
+                providerClient.use({
+                    onRequest: async ({ request }) => {
+                        this.logger.debug({
+                            hasAuthHeader: Boolean(request.headers.get('Authorization')),
+                            hasBody: Boolean(request.body),
+                            method: request.method,
+                            url: request.url,
+                        }, 'Requesting');
+                    },
+                });
+            }
+            if (initToken !== this.providerClientInitToken) {
+                this.logger.debug({ initToken, providerClientInitToken: this.providerClientInitToken }, 'Skipping provider client assignment (superseded)');
+                return;
+            }
             this._providerClient = providerClient;
+            this.providerClientOptions = options;
         }, rebuild);
     }
     setupRuntimeConfig(config) {
-        if (this.initQueue.size > 0) {
-            throw new Error('Cannot change runtime config after initialization has started');
-        }
+        const previousRuntimeConfigFile = this.runtimeConfigFile;
         if (config.configFile) {
             this.runtimeConfigFile = path.isAbsolute(config.configFile)
                 ? config.configFile
@@ -180,18 +206,62 @@ export class AppContainer {
         else {
             this.runtimeConfigFile = undefined;
         }
+        const changed = previousRuntimeConfigFile !== this.runtimeConfigFile;
+        if (changed) {
+            this.logger.debug({ previousRuntimeConfigFile, runtimeConfigFile: this.runtimeConfigFile }, 'Runtime config changed; clearing dependent services');
+            this._configManager = undefined;
+            this._accountManager = undefined;
+            this._providerClient = undefined;
+            this.providerClientOptions = undefined;
+            this.initQueue.delete('configManager');
+            this.initQueue.delete('accountManager');
+            this.initQueue.delete('providerClient');
+            this.initQueue.delete('blockchainConnector');
+            this.initQueue.delete('configFileManager');
+        }
+        if (this._configFileManager) {
+            this._configFileManager.setRuntimeConfigFile(this.runtimeConfigFile);
+        }
         return this;
     }
+    async getProviderClientForBootstrap() {
+        if (this._providerClient) {
+            return this._providerClient;
+        }
+        const queued = this.initQueue.get('providerClient');
+        if (queued) {
+            await queued;
+            return this.providerClient;
+        }
+        await this.waitFor('configManager', { required: true });
+        const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
+        this.logger.debug({ providerUrl }, 'Creating bootstrap provider client');
+        return createProviderClient({
+            baseUrl: providerUrl,
+            logger: this.logger,
+            middlewares: [requestIdMiddleware, loggerMiddleware],
+        });
+    }
     queueInit(name, task, force = false) {
-        if (!this.initQueue.has(name) || force) {
-            const promise = task();
-            this.initQueue.set(name, promise);
-            this.initPromises.push(promise);
+        if (force) {
+            this.initQueue.delete(name);
+        }
+        if (!this.initQueue.has(name)) {
+            const wrappedPromise = task().catch((error) => {
+                if (this.initQueue.get(name) === wrappedPromise) {
+                    this.initQueue.delete(name);
+                }
+                throw error;
+            });
+            this.initQueue.set(name, wrappedPromise);
         }
         return this;
     }
-    async waitFor(name) {
+    async waitFor(name, options = {}) {
         const promise = this.initQueue.get(name);
+        if (!promise && options.required) {
+            throw new Error(`Dependency "${name}" was not queued for initialization`);
+        }
         if (promise) {
             await promise;
         }

package/dist/logger.d.ts

@@ -1,4 +1,4 @@
-import { Interfaces } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
 import pino from 'pino';
 declare const _default: Interfaces.Logger & {
     getPino(): pino.Logger;

package/dist/logger.js

@@ -43,7 +43,10 @@ class PinoLogger {
         this.forward('warn', formatter, args);
     }
     forward(level, formatter, args) {
-        this.logger[level].apply(this.logger, [formatter, ...args]);
+        this.logger[level].apply(this.logger, [
+            formatter,
+            ...args,
+        ]);
     }
 }
 const logger = (namespace) => {

package/dist/managers/account-manager.d.ts

@@ -1,7 +1,7 @@
-import pino from 'pino';
-import { Account } from '../config/config.schema.js';
-import { IAccountManager } from '../interfaces/account-manager.interface.js';
-import { IConfigManager } from '../interfaces/config-manager.interface.js';
+import type pino from 'pino';
+import { type Account } from '../config/config.schema.js';
+import type { IAccountManager } from '../interfaces/account-manager.interface.js';
+import type { IConfigManager } from '../interfaces/config-manager.interface.js';
 export declare class AccountManager implements IAccountManager {
     private readonly configManager;
     private readonly logger;
@@ -12,9 +12,8 @@ export declare class AccountManager implements IAccountManager {
     createFromKey(privateKey: string): Promise<Account>;
     createSign(nonce: string): Promise<string>;
     getAddress(): string;
+    hasAccount(): Promise<boolean>;
     init(): Promise<void>;
-    interactWithUser(): Promise<{
-        address: string;
-        privateKey: string;
-    }>;
+    private loadAccount;
+    private save;
 }

package/dist/managers/account-manager.js

@@ -1,16 +1,7 @@
-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;
-};
-import { confirm, isCancel, password } from '@clack/prompts';
-import { ux } from '@oclif/core';
 import { Value } from 'typebox/value';
-import { Retryable } from 'typescript-retry-decorator';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { accountSchema } from '../config/config.schema.js';
-import { NotInitializedError } from '../errors.js';
+import { AccountNotFoundError, NotInitializedError } from '../errors.js';
 export class AccountManager {
     configManager;
     logger;
@@ -27,7 +18,7 @@ export class AccountManager {
             address: account.address,
             privateKey: this.privateKey,
         };
-        await this.configManager.set('account', this.account);
+        await this.save();
         this.logger.debug('Created new account');
         return this.account;
     }
@@ -38,7 +29,7 @@ export class AccountManager {
             address: account.address,
             privateKey: this.privateKey,
         };
-        await this.configManager.set('account', this.account);
+        await this.save();
         this.logger.debug('Created new account from key');
         return this.account;
     }
@@ -57,48 +48,32 @@ export class AccountManager {
         }
         return this.account.address;
     }
-    async init() {
+    async hasAccount() {
         const account = await this.configManager.get('account');
+        return Value.Check(accountSchema, account);
+    }
+    async init() {
         try {
-            this.account = Value.Parse(accountSchema, account);
-            this.privateKey = this.account.privateKey;
+            await this.loadAccount();
         }
         catch (error) {
-            this.logger.warn({ err: error }, 'Incorrect config file');
-            await this.interactWithUser();
+            if (!(error instanceof AccountNotFoundError)) {
+                this.logger.warn({ err: error }, 'Unexpected error loading account');
+            }
         }
     }
-    async interactWithUser() {
-        ux.warn("Account doesn't exist in current configuration");
-        const ask = await confirm({
-            message: 'Do you want to create a new account?',
-        });
-        if (isCancel(ask)) {
-            ux.error('Operation cancelled.', { exit: 1 });
-        }
-        if (ask) {
-            const account = await this.create();
-            ux.stdout('Generated new keyPair for new account.');
-            return account;
-        }
-        const privateKeyInput = await password({ message: 'Please input your privateKey for using in account' });
-        if (isCancel(privateKeyInput)) {
-            ux.error('Operation cancelled.', { exit: 1 });
-        }
-        const privateKey = privateKeyInput.trim();
+    async loadAccount() {
+        const account = await this.configManager.get('account');
         try {
-            const account = await this.createFromKey(privateKey);
-            ux.stdout('Your privateKey will be used in config. Keypair created');
-            return account;
+            this.account = Value.Parse(accountSchema, account);
+            this.privateKey = this.account.privateKey;
         }
         catch (error) {
-            ux.warn(error);
-            ux.error('Invalid private key format. Please try again.');
+            this.logger.warn({ err: error }, 'Incorrect config file');
+            throw new AccountNotFoundError('Account not found in config file');
         }
     }
+    async save() {
+        await this.configManager.set('account', this.account);
+    }
 }
-__decorate([
-    Retryable({
-        maxAttempts: 3,
-    })
-], AccountManager.prototype, "interactWithUser", null);

package/dist/managers/config-file-manager.d.ts

@@ -1,8 +1,8 @@
 import { confirm, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import pino from 'pino';
-import { CliConfig } from '../config/config.schema.js';
-import { IManager } from '../interfaces/manager.interface.js';
+import type pino from 'pino';
+import { type Account, type CliConfig } from '../config/config.schema.js';
+import type { IManager } from '../interfaces/manager.interface.js';
 type ConfirmPrompt = typeof confirm;
 type SelectPrompt = typeof select;
 type UxLike = Pick<typeof ux, 'error' | 'stdout'>;
@@ -14,7 +14,7 @@ interface ConfigFileManagerOptions {
 }
 export declare class ConfigFileManager implements IManager {
     private readonly logger;
-    private static readonly CONFIG_FILE;
+    static readonly CONFIG_FILE = "config.json";
     private static readonly CONFIGS_DIR;
     private readonly configDir;
     private readonly configFilePath;
@@ -25,8 +25,7 @@ export declare class ConfigFileManager implements IManager {
     private readonly selectPrompt;
     private readonly ux;
     constructor(configDir: string, logger: pino.BaseLogger, options?: ConfigFileManagerOptions);
-    addConfig(configName: string): Promise<void>;
-    createConfig(configFileName: string, name: string, url?: string): Promise<void>;
+    createConfig(configFileName: string, name: string, url?: string, account?: Account): Promise<void>;
     deleteConfig(configName: string): Promise<void>;
     deleteConfigByName(name?: string, force?: boolean): Promise<void>;
     getConfigData(configName: string): CliConfig | undefined;
@@ -40,7 +39,7 @@ export declare class ConfigFileManager implements IManager {
     getCurrentConfigPath(): Promise<string>;
     importConfig(sourcePath: string, targetName?: string): Promise<string>;
     init(): Promise<void>;
-    removeConfig(configName: string): Promise<void>;
+    private removeConfig;
     setCurrentConfig(configName: string): Promise<void>;
     setRuntimeConfigFile(runtimeConfigFile?: string): void;
     private ensureDirectories;