@super-protocol/sp-cli 0.0.6 → 0.0.7

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;

package/dist/managers/config-file-manager.js

@@ -1,7 +1,7 @@
-import { confirm, isCancel, select } from '@clack/prompts';
-import { ux } from '@oclif/core';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { confirm, isCancel, select } from '@clack/prompts';
+import { ux } from '@oclif/core';
 import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
 import { DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME, DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, } from '../constants.js';
@@ -9,11 +9,10 @@ import { getConfigName } from '../utils/helper.js';
 export class ConfigFileManager {
     logger;
     static CONFIG_FILE = 'config.json';
-    static CONFIGS_DIR = 'configs';
+    static CONFIGS_DIR = 'accounts';
     configDir;
     configFilePath;
     configs = {
-        configs: [],
         currentConfig: undefined,
     };
     configsDir;
@@ -31,13 +30,7 @@ export class ConfigFileManager {
         this.ux = options.ux ?? ux;
         this.runtimeConfigFile = options.runtimeConfigFile;
     }
-    async addConfig(configName) {
-        if (!this.configs.configs.includes(configName)) {
-            this.configs.configs.push(configName);
-            await this.save();
-        }
-    }
-    async createConfig(configFileName, name, url) {
+    async createConfig(configFileName, name, url, account) {
         const configPath = path.join(this.configsDir, configFileName);
         if (fs.existsSync(configPath)) {
             throw new Error(`Configuration file already exists: ${configFileName}`);
@@ -46,12 +39,14 @@ export class ConfigFileManager {
         if (url) {
             config.providerUrl = url;
         }
+        if (account) {
+            config.account = account;
+        }
         fs.writeFileSync(configPath, JSON.stringify(config, undefined, 2), {
             encoding: 'utf8',
             flag: 'w',
             mode: FILE_ACCESS_PERMS,
         });
-        await this.addConfig(configFileName);
         this.logger.info({ configFileName, name, url }, 'Created new configuration');
     }
     async deleteConfig(configName) {
@@ -71,7 +66,7 @@ export class ConfigFileManager {
         }
         let configToDelete;
         if (name) {
-            const config = configs.find(c => c.name === name);
+            const config = configs.find((c) => c.name === name);
             if (!config) {
                 this.ux.error(`Configuration not found: ${name}`);
             }
@@ -80,7 +75,7 @@ export class ConfigFileManager {
         else {
             const selection = await this.selectPrompt({
                 message: 'Select configuration to delete:',
-                options: configs.map(config => ({
+                options: configs.map((config) => ({
                     label: config.name,
                     value: config.file,
                 })),
@@ -91,7 +86,7 @@ export class ConfigFileManager {
             }
             configToDelete = selection;
         }
-        const configToDeleteData = configs.find(c => c.file === configToDelete);
+        const configToDeleteData = configs.find((c) => c.file === configToDelete);
         const displayName = configToDeleteData?.name || configToDelete;
         if (!force) {
             const confirmed = await this.confirmPrompt({
@@ -108,12 +103,12 @@ export class ConfigFileManager {
             this.ux.stdout(`Successfully deleted configuration: ${displayName}`);
             const newCurrent = this.getCurrentConfigFile();
             if (newCurrent) {
-                const newCurrentConfig = configs.find(c => c.file === newCurrent);
+                const newCurrentConfig = configs.find((c) => c.file === newCurrent);
                 this.ux.stdout(`Current configuration is now: ${newCurrentConfig?.name || newCurrent}`);
             }
             else {
                 this.ux.stdout('No configurations remaining');
-                this.ux.stdout('Create a new configuration with: sp config create --name "Config Name" or sp auth login');
+                this.ux.stdout('Create a new account with: sp account login --name "Account Name" or sp auth login');
             }
         }
         catch (error) {
@@ -138,10 +133,19 @@ export class ConfigFileManager {
         return this.configsDir;
     }
     getConfigs() {
-        return [...this.configs.configs];
+        if (!fs.existsSync(this.configsDir)) {
+            return [];
+        }
+        return fs.readdirSync(this.configsDir).filter((file) => file.endsWith('.config.json'));
     }
     getConfigsWithNames() {
-        return this.configs.configs.map(configFile => {
+        if (!fs.existsSync(this.configsDir)) {
+            return [];
+        }
+        const configFiles = fs
+            .readdirSync(this.configsDir)
+            .filter((file) => file.endsWith('.config.json'));
+        return configFiles.map((configFile) => {
             const configPath = path.join(this.configsDir, configFile);
             let name = configFile;
             try {
@@ -218,7 +222,6 @@ export class ConfigFileManager {
         }
         fs.copyFileSync(sourcePath, targetPath);
         fs.chmodSync(targetPath, FILE_ACCESS_PERMS);
-        await this.addConfig(targetFileName);
         this.logger.info({ sourcePath, targetFileName }, 'Imported configuration');
         return targetFileName;
     }
@@ -231,12 +234,10 @@ export class ConfigFileManager {
         await this.load();
     }
     async removeConfig(configName) {
-        const index = this.configs.configs.indexOf(configName);
-        if (index !== -1) {
-            this.configs.configs.splice(index, 1);
-            if (this.configs.currentConfig === configName) {
-                this.configs.currentConfig = this.configs.configs[0];
-            }
+        if (this.configs.currentConfig === configName) {
+            const configs = this.getConfigs();
+            const remainingConfigs = configs.filter((c) => c !== configName);
+            this.configs.currentConfig = remainingConfigs.length > 0 ? remainingConfigs[0] : undefined;
             await this.save();
         }
     }
@@ -245,9 +246,6 @@ export class ConfigFileManager {
         if (!fs.existsSync(configPath)) {
             throw new Error(`Configuration file not found: ${configName}`);
         }
-        if (!this.configs.configs.includes(configName)) {
-            this.configs.configs.push(configName);
-        }
         this.configs.currentConfig = configName;
         await this.save();
     }
@@ -256,10 +254,16 @@ export class ConfigFileManager {
     }
     ensureDirectories() {
         if (!fs.existsSync(this.configDir)) {
-            fs.mkdirSync(this.configDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+            fs.mkdirSync(this.configDir, {
+                mode: DIR_ACCESS_PERMS,
+                recursive: true,
+            });
         }
         if (!fs.existsSync(this.configsDir)) {
-            fs.mkdirSync(this.configsDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+            fs.mkdirSync(this.configsDir, {
+                mode: DIR_ACCESS_PERMS,
+                recursive: true,
+            });
         }
     }
     async load() {
@@ -277,7 +281,6 @@ export class ConfigFileManager {
         catch (error) {
             this.logger.error({ err: error }, 'Failed to load config manager file, using defaults');
             this.configs = {
-                configs: [],
                 currentConfig: undefined,
             };
             await this.save();

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

@@ -1,6 +1,6 @@
-import pino from 'pino';
-import { Auth, CliConfig } from '../config/config.schema.js';
-import { IConfigManager } from '../interfaces/config-manager.interface.js';
+import type pino from 'pino';
+import type { Auth, CliConfig } from '../config/config.schema.js';
+import type { IConfigManager } from '../interfaces/config-manager.interface.js';
 export declare class ConfigManager implements IConfigManager {
     private readonly configFile;
     private readonly logger;
@@ -8,14 +8,14 @@ export declare class ConfigManager implements IConfigManager {
     private readonly configDir;
     constructor(configFile: string, logger: pino.BaseLogger);
     get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
-    getConfig(): CliConfig;
+    private getConfig;
     getCookies(): Promise<unknown>;
     getCredentials(): Promise<{
         accessKey: string;
     } | undefined>;
     init(): Promise<void>;
     load(): Promise<CliConfig>;
-    makeBackup(): void;
+    private makeBackup;
     save(): Promise<void>;
     set<K extends keyof CliConfig, V extends CliConfig[K]>(key: K, value: V): Promise<void>;
     setCookies(cookies: unknown): Promise<void>;

package/dist/managers/config-manager.js

@@ -1,6 +1,6 @@
-import { ux } from '@oclif/core';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { ux } from '@oclif/core';
 import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
 import { ConfigurationNotFoundError } from '../errors.js';
 export class ConfigManager {
@@ -62,7 +62,10 @@ export class ConfigManager {
         }
     }
     async save() {
-        fs.mkdirSync(this.configDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+        fs.mkdirSync(this.configDir, {
+            mode: DIR_ACCESS_PERMS,
+            recursive: true,
+        });
         this.logger.debug({ configFile: this.getConfigPath() }, 'Saving config file');
         fs.writeFileSync(this.getConfigPath(), JSON.stringify(this.config, undefined, '  '), {
             encoding: 'utf8',

package/dist/middlewares/auth-middleware.d.ts

@@ -1,6 +1,6 @@
 import type { MiddlewareFn, ProviderClient } from '@super-protocol/provider-client';
 import type pino from 'pino';
-import { type Auth } from '../config/config.schema.js';
+import type { Auth } from '../config/config.schema.js';
 interface CredentialsStorage {
     getCredentials(): Promise<Auth | undefined>;
     setCredentials(auth: Auth): void;