@super-protocol/sp-cli 0.0.1-alpha.35 → 0.0.2

package/dist/lib/container.js

@@ -0,0 +1,177 @@
+import { createProviderClient, loggerMiddleware, requestIdMiddleware, } from '@super-protocol/provider-client';
+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 { createAuthMiddleware } from '../middlewares/auth-middleware.js';
+import { createCookieMiddleware } from '../middlewares/cookies-middleware.js';
+export class AppContainer {
+    cwdDir;
+    oclifConfig;
+    static appContainer;
+    _accountManager;
+    _configFileManager;
+    _configManager;
+    _providerClient;
+    initPromises = [];
+    initQueue = new Map();
+    logger;
+    runtimeConfigFile;
+    runtimeProviderUrl;
+    constructor(cwdDir, oclifConfig) {
+        this.cwdDir = cwdDir;
+        this.oclifConfig = oclifConfig;
+        this.logger = logger.getPino();
+    }
+    static initialize(currentDir, config) {
+        if (!AppContainer.appContainer) {
+            AppContainer.appContainer = new AppContainer(currentDir, config);
+        }
+        return AppContainer.appContainer;
+    }
+    get accountManager() {
+        if (!this._accountManager) {
+            throw new Error('Account manager not initialized');
+        }
+        return this._accountManager;
+    }
+    get configFileManager() {
+        if (!this._configFileManager) {
+            throw new Error('ConfigFile manager not initialized');
+        }
+        return this._configFileManager;
+    }
+    get configManager() {
+        if (!this._configManager) {
+            throw new Error('Config manager not initialized');
+        }
+        return this._configManager;
+    }
+    static get container() {
+        if (!AppContainer.appContainer) {
+            throw new Error('AppContainer not initialized');
+        }
+        return AppContainer.appContainer;
+    }
+    get providerClient() {
+        if (!this._providerClient) {
+            throw new Error('Provider client not initialized');
+        }
+        return this._providerClient;
+    }
+    async build() {
+        await Promise.all(this.initPromises);
+    }
+    initAccountManager() {
+        this.initConfigManager();
+        return this.queueInit('accountManager', async () => {
+            await this.waitFor('configManager');
+            if (this._accountManager) {
+                return;
+            }
+            this.logger.info('Initializing account manager');
+            const accountManager = new AccountManager(this.configManager, this.logger);
+            await accountManager.init();
+            this._accountManager = accountManager;
+        });
+    }
+    initConfigFileManager() {
+        return this.queueInit('configFileManager', async () => {
+            if (this._configFileManager) {
+                return;
+            }
+            const configFileManager = new ConfigFileManager(this.oclifConfig.configDir, this.logger, {
+                runtimeConfigFile: this.runtimeConfigFile,
+            });
+            await configFileManager.init();
+            this._configFileManager = configFileManager;
+        });
+    }
+    initConfigManager() {
+        this.initConfigFileManager();
+        return this.queueInit('configManager', async () => {
+            await this.waitFor('configFileManager');
+            if (this._configManager) {
+                return;
+            }
+            const configFilePath = this.configFileManager.getCurrentConfigPath();
+            if (!configFilePath) {
+                throw new Error('Config file not found');
+            }
+            this.logger.info('Initializing config manager');
+            const configManager = new ConfigManager(configFilePath, this.logger);
+            await configManager.init();
+            this._configManager = configManager;
+        });
+    }
+    initProviderClient({ enableAuth = true, enableCookies = true } = {}) {
+        this.initConfigManager();
+        return this.queueInit('providerClient', async () => {
+            if (this._providerClient) {
+                return;
+            }
+            await this.waitFor('configManager');
+            const providerUrl = this.runtimeProviderUrl || await this.configManager.get('providerUrl') || PROVIDER_URL;
+            this.logger.info('Initializing provider client');
+            const providerClient = createProviderClient({
+                baseUrl: providerUrl,
+                logger: this.logger,
+                middlewares: [requestIdMiddleware, loggerMiddleware],
+            });
+            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,
+                        url: req.url,
+                    }, 'Requesting');
+                },
+            });
+            if (enableCookies) {
+                this.logger.info('Initializing cookie middleware');
+                const cookiesMiddleware = await createCookieMiddleware(this.configManager, this.logger, providerUrl);
+                providerClient.use(cookiesMiddleware);
+            }
+            if (enableAuth) {
+                this.logger.info('Initializing auth middleware');
+                const authMiddleware = await createAuthMiddleware(this.configManager, providerClient, this.logger);
+                providerClient.use(authMiddleware);
+            }
+            this._providerClient = providerClient;
+        });
+    }
+    setupRuntimeConfig(config) {
+        if (this.initQueue.size > 0) {
+            throw new Error('Cannot change runtime config after initialization has started');
+        }
+        this.runtimeProviderUrl = config.url;
+        if (config.configFile) {
+            this.runtimeConfigFile = path.isAbsolute(config.configFile)
+                ? config.configFile
+                : path.join(this.cwdDir, config.configFile);
+        }
+        else {
+            this.runtimeConfigFile = undefined;
+        }
+        return this;
+    }
+    queueInit(name, task) {
+        if (!this.initQueue.has(name)) {
+            const promise = task();
+            this.initQueue.set(name, promise);
+            this.initPromises.push(promise);
+        }
+        return this;
+    }
+    async waitFor(name) {
+        const promise = this.initQueue.get(name);
+        if (promise) {
+            await promise;
+        }
+    }
+}

package/dist/logger.d.ts

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

package/dist/logger.js

@@ -0,0 +1,62 @@
+import pino from 'pino';
+const formatMsgPrefix = (namespace) => namespace ? `[${namespace}] ` : undefined;
+class PinoLogger {
+    rootLogger;
+    namespaceValue;
+    logger;
+    constructor(rootLogger, namespaceValue) {
+        this.rootLogger = rootLogger;
+        this.namespaceValue = namespaceValue;
+        this.logger = namespaceValue
+            ? rootLogger.child({ namespace: namespaceValue }, { msgPrefix: formatMsgPrefix(namespaceValue) })
+            : rootLogger;
+    }
+    get namespace() {
+        return this.namespaceValue;
+    }
+    child(namespace) {
+        const normalizedNamespace = (namespace || '').trim();
+        if (!normalizedNamespace) {
+            return this;
+        }
+        const childNamespace = this.namespaceValue
+            ? `${this.namespaceValue}:${normalizedNamespace}`
+            : normalizedNamespace;
+        return new PinoLogger(this.rootLogger, childNamespace);
+    }
+    debug(formatter, ...args) {
+        this.forward('debug', formatter, args);
+    }
+    error(formatter, ...args) {
+        this.forward('error', formatter, args);
+    }
+    getPino() {
+        return this.logger;
+    }
+    info(formatter, ...args) {
+        this.forward('info', formatter, args);
+    }
+    trace(formatter, ...args) {
+        this.forward('trace', formatter, args);
+    }
+    warn(formatter, ...args) {
+        this.forward('warn', formatter, args);
+    }
+    forward(level, formatter, args) {
+        this.logger[level].apply(this.logger, [formatter, ...args]);
+    }
+}
+const logger = (namespace) => {
+    const normalizedNamespace = (namespace || '').trim();
+    const pinoLogger = pino({
+        level: process.env.SP_LOG_LEVEL || 'silent',
+        transport: {
+            options: {
+                colorize: true,
+            },
+            target: 'pino-pretty',
+        },
+    });
+    return new PinoLogger(pinoLogger, normalizedNamespace);
+};
+export default logger('sp');

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

@@ -8,8 +8,8 @@ export declare class AccountManager implements IAccountManager {
     account?: Account;
     private privateKey?;
     constructor(configManager: IConfigManager, logger: pino.BaseLogger);
-    create(): Account;
-    createFromKey(privateKey: string): Account;
+    create(): Promise<Account>;
+    createFromKey(privateKey: string): Promise<Account>;
     createSign(nonce: string): Promise<string>;
     getAddress(): string;
     init(): Promise<void>;

package/dist/managers/account-manager.js

@@ -20,25 +20,25 @@ export class AccountManager {
         this.configManager = configManager;
         this.logger = logger;
     }
-    create() {
+    async create() {
         this.privateKey = generatePrivateKey();
         const account = privateKeyToAccount(this.privateKey);
         this.account = {
             address: account.address,
             privateKey: this.privateKey,
         };
-        this.configManager.set('account', this.account);
+        await this.configManager.set('account', this.account);
         this.logger.debug('Created new account');
         return this.account;
     }
-    createFromKey(privateKey) {
+    async createFromKey(privateKey) {
         this.privateKey = privateKey;
         const account = privateKeyToAccount(this.privateKey);
         this.account = {
             address: account.address,
             privateKey: this.privateKey,
         };
-        this.configManager.set('account', this.account);
+        await this.configManager.set('account', this.account);
         this.logger.debug('Created new account from key');
         return this.account;
     }
@@ -48,7 +48,7 @@ export class AccountManager {
         }
         const account = privateKeyToAccount(this.privateKey);
         const sign = await account.signMessage({ message: nonce });
-        this.logger.debug({ nonce, sign }, 'Created new signature for nonce');
+        this.logger.debug({ address: account.address, nonce }, 'Created new signature for nonce');
         return sign;
     }
     getAddress() {
@@ -64,8 +64,17 @@ export class AccountManager {
             this.privateKey = this.account.privateKey;
         }
         catch (error) {
-            ux.warn(error);
-            await this.promptAccount();
+            this.logger.warn({ err: error }, 'Incorrect config file');
+            ux.warn('Config not found or have errors');
+            const ask = await confirm({
+                message: 'Do you want to create new one?',
+            });
+            if (ask) {
+                await this.promptAccount();
+            }
+            else {
+                ux.error('Credentials not generated please check config file and rerun command again', { exit: 1 });
+            }
         }
     }
     async promptAccount() {
@@ -75,7 +84,7 @@ export class AccountManager {
         if (askPrivateKey) {
             const privateKey = await password({ message: 'Please input your privateKey for using in account' });
             try {
-                const account = this.createFromKey(privateKey);
+                const account = await this.createFromKey(privateKey);
                 ux.stdout('Your privateKey will be used in config. Keypair created');
                 return account;
             }
@@ -84,7 +93,7 @@ export class AccountManager {
                 ux.error('Invalid private key format. Please try again.');
             }
         }
-        const account = this.create();
+        const account = await this.create();
         ux.stdout('Generated new keyPair for new account.');
         return account;
     }

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

@@ -0,0 +1,50 @@
+import { confirm, select } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import pino from 'pino';
+import { CliConfig } from '../config/config.schema.js';
+import { IManager } from '../interfaces/manager.interface.js';
+type ConfirmPrompt = typeof confirm;
+type SelectPrompt = typeof select;
+type UxLike = Pick<typeof ux, 'error' | 'stdout'>;
+interface ConfigFileManagerOptions {
+    confirmPrompt?: ConfirmPrompt;
+    runtimeConfigFile?: string;
+    selectPrompt?: SelectPrompt;
+    ux?: UxLike;
+}
+export declare class ConfigFileManager implements IManager {
+    private readonly logger;
+    private static readonly CONFIG_FILE;
+    private static readonly CONFIGS_DIR;
+    private readonly configDir;
+    private readonly configFilePath;
+    private configs;
+    private readonly configsDir;
+    private readonly confirmPrompt;
+    private runtimeConfigFile?;
+    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>;
+    deleteConfig(configName: string): Promise<void>;
+    deleteConfigByName(name?: string, force?: boolean): Promise<void>;
+    getConfigData(configName: string): CliConfig | undefined;
+    getConfigDir(): string;
+    getConfigs(): string[];
+    getConfigsWithNames(): Array<{
+        file: string;
+        name: string;
+    }>;
+    getCurrentConfigFile(): string | undefined;
+    getCurrentConfigPath(): string | undefined;
+    importConfig(sourcePath: string, targetName?: string): Promise<string>;
+    init(): Promise<void>;
+    removeConfig(configName: string): Promise<void>;
+    setCurrentConfig(configName: string): Promise<void>;
+    setRuntimeConfigFile(runtimeConfigFile?: string): void;
+    private ensureDirectories;
+    private load;
+    private save;
+}
+export {};

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

@@ -0,0 +1,278 @@
+import { confirm, select } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import { Value } from '@sinclair/typebox/value';
+import * as fs from 'node:fs';
+import path from 'node:path';
+import { cliConfigSchema } from '../config/config.schema.js';
+import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
+import { getConfigName } from '../utils/helper.js';
+export class ConfigFileManager {
+    logger;
+    static CONFIG_FILE = 'config.json';
+    static CONFIGS_DIR = 'configs';
+    configDir;
+    configFilePath;
+    configs = {
+        configs: [],
+        currentConfig: undefined,
+    };
+    configsDir;
+    confirmPrompt;
+    runtimeConfigFile;
+    selectPrompt;
+    ux;
+    constructor(configDir, logger, options = {}) {
+        this.logger = logger;
+        this.configDir = configDir;
+        this.configFilePath = path.join(this.configDir, ConfigFileManager.CONFIG_FILE);
+        this.configsDir = path.join(this.configDir, ConfigFileManager.CONFIGS_DIR);
+        this.confirmPrompt = options.confirmPrompt ?? confirm;
+        this.selectPrompt = options.selectPrompt ?? select;
+        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) {
+        const configPath = path.join(this.configsDir, configFileName);
+        if (fs.existsSync(configPath)) {
+            throw new Error(`Configuration file already exists: ${configFileName}`);
+        }
+        const config = { name };
+        if (url) {
+            config.providerUrl = url;
+        }
+        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) {
+        const configPath = path.join(this.configsDir, configName);
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Configuration file not found: ${configName}`);
+        }
+        await this.removeConfig(configName);
+        fs.unlinkSync(configPath);
+        this.logger.info({ configName }, 'Deleted configuration file');
+    }
+    async deleteConfigByName(name, force) {
+        const configs = this.getConfigsWithNames();
+        if (configs.length === 0) {
+            this.ux.stdout('No configurations found');
+            return;
+        }
+        let configToDelete;
+        if (name) {
+            const config = configs.find(c => c.name === name);
+            if (!config) {
+                this.ux.error(`Configuration not found: ${name}`);
+            }
+            configToDelete = config.file;
+        }
+        else {
+            configToDelete = await this.selectPrompt({
+                choices: configs.map(config => ({
+                    name: config.name,
+                    value: config.file,
+                })),
+                message: 'Select configuration to delete:',
+            });
+        }
+        const configToDeleteData = configs.find(c => c.file === configToDelete);
+        const displayName = configToDeleteData?.name || configToDelete;
+        if (!force) {
+            const confirmed = await this.confirmPrompt({
+                default: false,
+                message: `Are you sure you want to delete configuration "${displayName}"?`,
+            });
+            if (!confirmed) {
+                this.ux.stdout('Deletion cancelled');
+                return;
+            }
+        }
+        try {
+            await this.deleteConfig(configToDelete);
+            this.ux.stdout(`Successfully deleted configuration: ${displayName}`);
+            const newCurrent = this.getCurrentConfigFile();
+            if (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');
+            }
+        }
+        catch (error) {
+            this.ux.error(`Failed to delete configuration: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    getConfigData(configName) {
+        const configPath = path.join(this.configsDir, configName);
+        if (!fs.existsSync(configPath)) {
+            return undefined;
+        }
+        try {
+            const raw = fs.readFileSync(configPath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            this.logger.warn({ configName, err: error }, 'Failed to read config data');
+            return undefined;
+        }
+    }
+    getConfigDir() {
+        return this.configsDir;
+    }
+    getConfigs() {
+        return [...this.configs.configs];
+    }
+    getConfigsWithNames() {
+        return this.configs.configs.map(configFile => {
+            const configPath = path.join(this.configsDir, configFile);
+            let name = configFile;
+            try {
+                if (fs.existsSync(configPath)) {
+                    const raw = fs.readFileSync(configPath, 'utf8');
+                    const config = JSON.parse(raw);
+                    if (config.name) {
+                        name = config.name;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.warn({ configFile, err: error }, 'Failed to read config name');
+            }
+            return { file: configFile, name };
+        });
+    }
+    getCurrentConfigFile() {
+        if (this.runtimeConfigFile) {
+            return path.basename(this.runtimeConfigFile);
+        }
+        return this.configs.currentConfig;
+    }
+    getCurrentConfigPath() {
+        if (this.runtimeConfigFile) {
+            return this.runtimeConfigFile;
+        }
+        if (!this.configs.currentConfig) {
+            return undefined;
+        }
+        return path.join(this.configsDir, this.configs.currentConfig);
+    }
+    async importConfig(sourcePath, targetName) {
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Source file not found: ${sourcePath}`);
+        }
+        let sourceConfig;
+        try {
+            const raw = fs.readFileSync(sourcePath, 'utf8');
+            sourceConfig = JSON.parse(raw);
+            if (!Value.Check(cliConfigSchema, sourceConfig)) {
+                throw new Error("Configuration doesn't match required schema");
+            }
+        }
+        catch (error) {
+            throw new Error(`Invalid configuration file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        let targetFileName;
+        if (targetName) {
+            targetFileName = getConfigName(targetName);
+        }
+        else if (sourceConfig.name) {
+            targetFileName = getConfigName(sourceConfig.name);
+        }
+        else {
+            const basename = path.basename(sourcePath, path.extname(sourcePath));
+            targetFileName = getConfigName(basename);
+        }
+        const targetPath = path.join(this.configsDir, targetFileName);
+        if (fs.existsSync(targetPath)) {
+            throw new Error(`Configuration file already exists: ${targetFileName}`);
+        }
+        fs.copyFileSync(sourcePath, targetPath);
+        fs.chmodSync(targetPath, FILE_ACCESS_PERMS);
+        await this.addConfig(targetFileName);
+        this.logger.info({ sourcePath, targetFileName }, 'Imported configuration');
+        return targetFileName;
+    }
+    async init() {
+        if (this.runtimeConfigFile) {
+            this.logger.debug({ runtimeConfigFile: this.runtimeConfigFile }, 'Runtime config provided, skipping config file initialization');
+            return;
+        }
+        this.ensureDirectories();
+        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];
+            }
+            await this.save();
+        }
+    }
+    async setCurrentConfig(configName) {
+        const configPath = path.join(this.configsDir, configName);
+        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();
+    }
+    setRuntimeConfigFile(runtimeConfigFile) {
+        this.runtimeConfigFile = runtimeConfigFile;
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(this.configDir)) {
+            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 });
+        }
+    }
+    async load() {
+        try {
+            if (fs.existsSync(this.configFilePath)) {
+                const raw = fs.readFileSync(this.configFilePath, 'utf8');
+                this.configs = JSON.parse(raw);
+                this.logger.debug({ configs: this.configs }, 'Configs loaded');
+            }
+            else {
+                this.logger.debug('Config manager file not found, using defaults');
+                await this.save();
+            }
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Failed to load config manager file, using defaults');
+            this.configs = {
+                configs: [],
+                currentConfig: undefined,
+            };
+            await this.save();
+        }
+    }
+    async save() {
+        this.ensureDirectories();
+        this.logger.debug({ configs: this.configs, path: this.configFilePath }, 'Saving config manager file');
+        fs.writeFileSync(this.configFilePath, JSON.stringify(this.configs, undefined, 2), {
+            encoding: 'utf8',
+            flag: 'w',
+            mode: FILE_ACCESS_PERMS,
+        });
+    }
+}