@super-protocol/sp-cli 0.0.5 → 0.0.7

package/dist/commands/{config/delete.js → account/forget.js}

@@ -1,11 +1,12 @@
 import { Flags } from '@oclif/core';
-import { BaseConfigCommand } from './base.js';
-export default class ConfigDelete extends BaseConfigCommand {
-    static description = 'Delete a configuration file';
+import { BaseAccountCommand } from './base.js';
+export default class AccountForget extends BaseAccountCommand {
+    static authenticate = false;
+    static description = 'Purge all account details';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --name "My Config"',
-        '<%= config.bin %> <%= command.id %> --name "My Config" --force',
+        '<%= config.bin %> <%= command.id %> --name "My Account"',
+        '<%= config.bin %> <%= command.id %> --name "My Account" --force',
     ];
     static flags = {
         force: Flags.boolean({
@@ -18,6 +19,12 @@ export default class ConfigDelete extends BaseConfigCommand {
             description: 'Configuration name to delete',
         }),
     };
+    configFileManager;
+    async init() {
+        await super.init();
+        await this.container.initConfigFileManager().build();
+        this.configFileManager = this.container.configFileManager;
+    }
     async run() {
         const { force, name } = this.flags;
         await this.configFileManager.deleteConfigByName(name, force);

package/dist/commands/account/get-sppi.d.ts

@@ -1,5 +1,5 @@
-import { BaseCommand } from '../base.js';
-export default class AccountGetSppi extends BaseCommand<typeof AccountGetSppi> {
+import { BaseAccountCommand } from './base.js';
+export default class AccountGetSppi extends BaseAccountCommand<typeof AccountGetSppi> {
     static description: string;
     static examples: string[];
     run(): Promise<{

package/dist/commands/account/get-sppi.js

@@ -1,23 +1,18 @@
 import { formatEther } from 'viem';
-import { BaseCommand } from '../base.js';
-export default class AccountGetSppi extends BaseCommand {
+import { BaseAccountCommand } from './base.js';
+export default class AccountGetSppi extends BaseAccountCommand {
     static description = 'Get SPPI (Super Protocol incentive tokens) ';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
-        const { providerClient } = await this.container
-            .initConfigFileManager()
-            .initConfigManager()
-            .initAccountManager()
-            .initProviderClient()
-            .build();
+        await this.initAccountContext();
+        const { providerClient } = this.container;
         const { data, error } = await providerClient.POST('/api/faucet/request-tokens');
         if (error) {
-            this.error(`Request tokens failed. Reason ${error.message}`);
+            this.error(`Getting SPPI failed. Reason: ${error.message}`);
         }
         const tokens = formatEther(BigInt(data.amount || '0'));
-        this.log(`Requested tokens: ${tokens} SPPI`);
+        this.log('Tokens replenished');
+        this.log(`Current balance: ${tokens} SPPI`);
         return { tokens };
     }
 }

package/dist/commands/account/info.d.ts

@@ -1,6 +1,9 @@
-import { BaseCommand } from '../base.js';
-export declare class InfoCommand extends BaseCommand<typeof InfoCommand> {
+import { BaseAccountCommand } from './base.js';
+export declare class InfoCommand extends BaseAccountCommand<typeof InfoCommand> {
     static description: string;
+    static flags: {
+        detail: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     init(): Promise<void>;
     run(): Promise<{
         address: string;

package/dist/commands/account/info.js

@@ -1,13 +1,22 @@
+import { Flags } from '@oclif/core';
 import { formatEther } from 'viem';
+import { PROVIDER_URL } from '../../constants.js';
 import { StorageService } from '../../services/storage.service.js';
-import { BaseCommand } from '../base.js';
-export class InfoCommand extends BaseCommand {
+import { BaseAccountCommand } from './base.js';
+export class InfoCommand extends BaseAccountCommand {
     static description = 'Information about current authorized user';
+    static flags = {
+        detail: Flags.boolean({
+            default: false,
+            description: 'Detailed information about Account',
+        }),
+    };
     async init() {
         await super.init();
-        await this.container.initProviderClient().initAccountManager().initConfigManager().build();
+        await this.initAccountContext();
     }
     async run() {
+        const { flags } = await this.parse(InfoCommand);
         const { providerClient } = this.container;
         const storageService = new StorageService(providerClient, this.logger);
         const { data, error } = await providerClient.GET('/api/auth/me');
@@ -36,6 +45,47 @@ export class InfoCommand extends BaseCommand {
                 this.log(`  prefix: ${storage.prefix}`);
             }
         }
+        if (flags.detail) {
+            const { configFileManager } = this.container;
+            const current = configFileManager.getCurrentConfigFile();
+            const configDir = configFileManager.getConfigDir();
+            this.log('\n-----------------(DETAILS)-----------------------');
+            if (current) {
+                const configs = configFileManager.getConfigsWithNames();
+                const currentConfig = configs.find((c) => c.file === current);
+                const displayName = currentConfig?.name || current;
+                const configData = configFileManager.getConfigData(current);
+                this.log(`Current configuration: ${displayName}`);
+                this.log(`Configuration file: ${current}`);
+                this.log(`Configuration directory: ${configDir}`);
+                if (configData) {
+                    this.log('\nConfiguration details:');
+                    if (configData.providerUrl) {
+                        this.log(`  Provider URL: ${configData.providerUrl}`);
+                    }
+                    else {
+                        this.log(`  Provider URL: ${PROVIDER_URL} (using default)`);
+                    }
+                    if (configData.auth?.accessKey) {
+                        this.log('  Authorization: Configured');
+                    }
+                    else {
+                        this.log('  Authorization: Unauthorized');
+                    }
+                    if (configData.account?.address) {
+                        this.log(`  Account: ${configData.account.address}`);
+                    }
+                    else {
+                        this.log('  Account: Not configured');
+                    }
+                }
+            }
+            else {
+                this.log('No configuration is currently set');
+                this.log(`Configuration directory: ${configDir}`);
+                this.log('Create a new configuration with: sp account login --privateKey "<PRIVATE_KEY>" --name "Account Name"');
+            }
+        }
         return {
             address: data.address,
             balance,

package/dist/commands/account/list.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../base.js';
+export default class AccountListCommand extends BaseCommand<typeof AccountListCommand> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    private configFileManager;
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/{config → account}/list.js

@@ -1,17 +1,23 @@
 import { printTable } from 'console-table-printer';
 import { PROVIDER_URL } from '../../constants.js';
-import { BaseConfigCommand } from './base.js';
-export default class ConfigList extends BaseConfigCommand {
-    static description = 'List all configurations';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+import { BaseCommand } from '../base.js';
+export default class AccountListCommand extends BaseCommand {
+    static authenticate = false;
+    static description = 'List all Accounts';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    configFileManager;
+    async init() {
+        await super.init();
+        await this.container.initConfigFileManager().build();
+        this.configFileManager = this.container.configFileManager;
+        await this.container.initConfigManager().build();
+    }
     async run() {
         const configs = this.configFileManager.getConfigsWithNames();
         const current = this.configFileManager.getCurrentConfigFile();
         if (configs.length === 0) {
-            this.log('No configurations found');
-            this.log('Create a new configuration with: sp config create --name "Config Name"');
+            this.log('No Accounts found');
+            this.log('Create a new account with: sp account login --privateKey "<PRIVATE_KEY>" --url "<PROVIDER_URL>" --name "Account Name"');
             return;
         }
         const rows = [];
@@ -34,7 +40,8 @@ export default class ConfigList extends BaseConfigCommand {
                 { name: 'account', title: 'Account' },
                 { name: 'url', title: 'Provider Url' },
                 { name: 'file', title: 'Configuration File' },
-            ], title: 'Available configurations',
+            ],
+            title: 'Available Accounts',
         });
     }
 }

package/dist/commands/account/login.d.ts

@@ -0,0 +1,35 @@
+import { BaseAccountCommand } from './base.js';
+export default class AccountLoginCommand extends BaseAccountCommand<typeof AccountLoginCommand> {
+    static aliases: string[];
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        privateKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private configFileManager;
+    private shouldSkipLogin;
+    private inputPrompt;
+    private checkStorage;
+    init(): Promise<void>;
+    run(): Promise<{
+        account: undefined;
+        success: boolean;
+    } | {
+        account: string;
+        success: boolean;
+    }>;
+    private askName;
+    private confirmPrompt;
+    private createAccountFromKey;
+    private createConfigIfMissing;
+    private findConfigsByPrivateKey;
+    private getPrivateKeyOrGenerate;
+    private resolveByName;
+    private resolveByPrivateKey;
+    private resolveConfiguration;
+    private static maskPrivateKey;
+}

package/dist/commands/account/login.js

@@ -0,0 +1,254 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { confirm, isCancel, text } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { PROVIDER_URL } from '../../constants.js';
+import { AuthService } from '../../services/auth.service.js';
+import { StorageService } from '../../services/storage.service.js';
+import { getConfigNameFromCredentials } from '../../utils/helper.js';
+import { BaseAccountCommand } from './base.js';
+export default class AccountLoginCommand extends BaseAccountCommand {
+    static aliases = ['login'];
+    static authenticate = false;
+    static description = 'Login to SuperProtocol (sign up or sign in).';
+    static examples = [
+        `<%= config.bin %> <%= command.id %>
+`,
+    ];
+    static flags = {
+        name: Flags.string({
+            description: 'Account readable name',
+        }),
+        privateKey: Flags.string({
+            description: 'Account private key used for authentication',
+        }),
+        url: Flags.string({
+            description: 'Provider base URL',
+            hidden: true,
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip questions (generate keys when needed).',
+        }),
+    };
+    configFileManager;
+    shouldSkipLogin = false;
+    async inputPrompt(options) {
+        const result = await text(options);
+        return this.ensurePromptValue(result);
+    }
+    async checkStorage() {
+        await this.container
+            .initProviderClient({ enableAuth: true, enableCookies: true, rebuild: true })
+            .build();
+        const { providerClient } = this.container;
+        const storageService = new StorageService(providerClient, this.logger);
+        if (!(await storageService.hasStorage())) {
+            this.logger.info('Requesting default storage');
+            const { id, isCentralized, storageType } = await storageService.getCentralizedStorage();
+            this.logger.info({ id, isCentralized, storageType }, 'Requested new storage');
+            await storageService.saveStorage(id);
+        }
+    }
+    async init() {
+        await super.init();
+        await this.container.initConfigFileManager().build();
+        this.configFileManager = this.container.configFileManager;
+        await this.resolveConfiguration();
+        if (this.shouldSkipLogin) {
+            return;
+        }
+        await this.initAccountContext({
+            assumeYes: this.flags.yes,
+            enableAuth: false,
+            enableCookies: true,
+        });
+    }
+    async run() {
+        if (this.shouldSkipLogin) {
+            return { account: undefined, success: false };
+        }
+        const { accountManager, configManager, providerClient } = this.container;
+        const authService = new AuthService(accountManager, configManager, providerClient, this.logger);
+        try {
+            await authService.auth({ force: true });
+        }
+        catch (error) {
+            this.error(error, { exit: 1 });
+        }
+        try {
+            await this.checkStorage();
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Storage initialization failed');
+            this.warn('Storage initialization failed. You can set up storage later using "sp storage create" or "sp storage select".');
+        }
+        const account = accountManager.getAddress();
+        this.log(`Logged in with account ${account}`);
+        return { account, success: true };
+    }
+    async askName(fallback) {
+        const value = await this.inputPrompt({
+            message: 'Configuration name:',
+            placeholder: fallback,
+        });
+        const trimmed = value.trim();
+        return trimmed || fallback;
+    }
+    async confirmPrompt(message, initialValue = true) {
+        const result = await confirm({ initialValue, message });
+        if (isCancel(result)) {
+            this.error('Operation cancelled.', { exit: 1 });
+        }
+        return Boolean(result);
+    }
+    createAccountFromKey(privateKey) {
+        try {
+            const account = privateKeyToAccount(privateKey);
+            return {
+                address: account.address,
+                privateKey: privateKey,
+            };
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Invalid private key provided.');
+            this.error('Invalid private key provided.');
+        }
+    }
+    async createConfigIfMissing(configFile, displayName, providerUrl, account) {
+        const configPath = path.join(this.configFileManager.getConfigDir(), configFile);
+        if (existsSync(configPath)) {
+            return;
+        }
+        await this.configFileManager.createConfig(configFile, displayName, providerUrl, account);
+        this.log(`Created configuration: ${displayName}`);
+    }
+    findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
+        const normalizedKey = privateKey.trim().toLowerCase();
+        const configs = this.configFileManager.getConfigsWithNames();
+        const matches = [];
+        for (const config of configs) {
+            const configData = this.configFileManager.getConfigData(config.file);
+            const storedKey = configData?.account?.privateKey?.toLowerCase();
+            const storedUrl = (configData?.providerUrl ?? PROVIDER_URL).trim();
+            const keyMatches = storedKey === normalizedKey;
+            const urlMatches = !matchProviderUrl || storedUrl === providerUrl;
+            if (keyMatches && urlMatches) {
+                matches.push(config);
+            }
+        }
+        return matches;
+    }
+    async getPrivateKeyOrGenerate() {
+        const generatedKey = generatePrivateKey();
+        if (this.flags.yes) {
+            return generatedKey;
+        }
+        const maskedKey = AccountLoginCommand.maskPrivateKey(generatedKey);
+        const value = await this.inputPrompt({
+            message: `Enter private key (or press Enter to use generated ${maskedKey}):`,
+            placeholder: maskedKey,
+        });
+        const trimmed = value.trim();
+        return trimmed || generatedKey;
+    }
+    async resolveByName(name, privateKey, providerUrl) {
+        const configs = this.configFileManager.getConfigsWithNames();
+        const normalized = name.toLowerCase();
+        const existingByName = configs.find((config) => config.name.toLowerCase() === normalized || config.file.toLowerCase() === normalized);
+        if (existingByName) {
+            await this.configFileManager.setCurrentConfig(existingByName.file);
+            return;
+        }
+        let shouldCreate = true;
+        if (!this.flags.yes) {
+            shouldCreate = await this.confirmPrompt(`Configuration "${name}" not found. Create it?`, true);
+        }
+        if (!shouldCreate) {
+            this.shouldSkipLogin = true;
+            return;
+        }
+        const resolvedKey = privateKey ?? (await this.getPrivateKeyOrGenerate());
+        const account = this.createAccountFromKey(resolvedKey);
+        const configFile = getConfigNameFromCredentials(resolvedKey, providerUrl);
+        await this.createConfigIfMissing(configFile, name, providerUrl, account);
+        let shouldSwitch = true;
+        if (!this.flags.yes) {
+            shouldSwitch = await this.confirmPrompt(`Switch to configuration "${name}" now?`, true);
+        }
+        if (!shouldSwitch) {
+            this.shouldSkipLogin = true;
+            return;
+        }
+        await this.configFileManager.setCurrentConfig(configFile);
+    }
+    async resolveByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
+        const matches = this.findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl);
+        if (matches.length === 1) {
+            await this.configFileManager.setCurrentConfig(matches[0].file);
+            return;
+        }
+        if (matches.length > 1) {
+            if (this.flags.yes) {
+                this.log(`Too many matched configs: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
+                await this.configFileManager.setCurrentConfig(matches[0].file);
+                return;
+            }
+            const selected = await this.selectPrompt({
+                message: 'Multiple configurations found for this private key. Select one:',
+                options: matches.map((match) => ({ label: match.name, value: match.file })),
+            });
+            await this.configFileManager.setCurrentConfig(selected);
+            return;
+        }
+        let shouldCreate = true;
+        if (!this.flags.yes) {
+            shouldCreate = await this.confirmPrompt('No configuration found for this private key. Create a new one?', true);
+        }
+        if (!shouldCreate) {
+            this.shouldSkipLogin = true;
+            return;
+        }
+        const account = this.createAccountFromKey(privateKey);
+        const suggestedName = this.flags.name?.trim() || account.address;
+        const displayName = this.flags.yes ? suggestedName : await this.askName(suggestedName);
+        const configFile = getConfigNameFromCredentials(privateKey, providerUrl);
+        await this.createConfigIfMissing(configFile, displayName, providerUrl, account);
+        let shouldSwitch = true;
+        if (!this.flags.yes) {
+            shouldSwitch = await this.confirmPrompt(`Switch to configuration "${displayName}" now?`, true);
+        }
+        if (!shouldSwitch) {
+            this.shouldSkipLogin = true;
+            return;
+        }
+        await this.configFileManager.setCurrentConfig(configFile);
+    }
+    async resolveConfiguration() {
+        const name = this.flags.name?.trim();
+        const privateKey = this.flags.privateKey?.trim();
+        const url = this.flags.url?.trim();
+        if (url !== undefined && !url) {
+            this.error('Provider URL cannot be empty.', { exit: 1 });
+        }
+        const providerUrl = (url || PROVIDER_URL).trim();
+        if (name) {
+            await this.resolveByName(name, privateKey, providerUrl);
+            return;
+        }
+        if (privateKey) {
+            await this.resolveByPrivateKey(privateKey, providerUrl, Boolean(url));
+        }
+    }
+    static maskPrivateKey(privateKey) {
+        const trimmed = privateKey.trim();
+        if (trimmed.length <= 14) {
+            return trimmed;
+        }
+        const start = trimmed.slice(0, 6);
+        const end = trimmed.slice(-4);
+        return `${start}…${end}`;
+    }
+}

package/dist/commands/account/switch.d.ts

@@ -0,0 +1,12 @@
+import type { ConfigFileManager, ConfigManager } from '../../managers/index.js';
+import { BaseAccountCommand } from './base.js';
+export default class AccountSwitchCommand extends BaseAccountCommand<typeof AccountSwitchCommand> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    protected configFileManager: ConfigFileManager;
+    protected configManager: ConfigManager;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    private switchConfig;
+}

package/dist/commands/account/switch.js

@@ -0,0 +1,40 @@
+import { BaseAccountCommand } from './base.js';
+export default class AccountSwitchCommand extends BaseAccountCommand {
+    static authenticate = false;
+    static description = 'Switch to a different account';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    configFileManager;
+    configManager;
+    async init() {
+        await super.init();
+        await this.container.initConfigFileManager().build();
+        this.configFileManager = this.container.configFileManager;
+        await this.container.initConfigManager().build();
+    }
+    async run() {
+        const configs = this.configFileManager.getConfigsWithNames();
+        const currentConfig = this.configFileManager.getCurrentConfigFile();
+        if (configs.length === 0) {
+            this.log('No accounts found');
+            this.log('Create a new account with: sp account login --privateKey "<PRIVATE_KEY>" --name "Account Name"');
+            return;
+        }
+        const selected = await this.selectPrompt({
+            initialValue: currentConfig,
+            message: 'Select an account:',
+            options: configs.map((config) => ({
+                label: config.name ?? config.file,
+                value: config.file,
+            })),
+        });
+        const selectedConfig = configs.find((c) => c.file === selected);
+        await this.switchConfig(selected, selectedConfig?.name || selected);
+    }
+    async switchConfig(configFile, displayName) {
+        await this.configFileManager.setCurrentConfig(configFile);
+        this.log(`Switched to account: ${displayName || configFile}`);
+        await this.initAccountContext({ enableAuth: false, enableCookies: true, rebuild: true });
+        this.configFileManager = this.container.configFileManager;
+        this.configManager = this.container.configManager;
+    }
+}

package/dist/commands/base.d.ts

@@ -1,9 +1,10 @@
-import { Command, Config, Interfaces } from '@oclif/core';
-import pino from 'pino';
+import { Command, type Config, type Interfaces } from '@oclif/core';
+import type pino from 'pino';
 import { AppContainer } from '../lib/container.js';
-export type CommandFlags<T extends typeof Command> = Interfaces.InferredFlags<T['flags'] & typeof BaseCommand['baseFlags']>;
+export type CommandFlags<T extends typeof Command> = Interfaces.InferredFlags<T['flags'] & (typeof BaseCommand)['baseFlags']>;
 export type CommandArgs<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
 export declare abstract class BaseCommand<T extends typeof Command> extends Command {
+    static authenticate: boolean;
     static baseFlags: typeof Command.baseFlags;
     static enableJsonFlag: boolean;
     protected args: CommandArgs<T>;

package/dist/commands/base.js

@@ -1,11 +1,13 @@
 import { isCancel } from '@clack/prompts';
-import { Command, Flags, } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
 import { AppContainer } from '../lib/container.js';
 import logger from '../logger.js';
 export class BaseCommand extends Command {
+    static authenticate = true;
     static baseFlags = {
         config: Flags.string({
             helpGroup: 'GLOBAL',
+            hidden: true,
             required: false,
             summary: 'Specify config file.',
         }),

package/dist/commands/files/download.js

@@ -4,9 +4,14 @@ import { createProgressPrinter } from '../../utils/progress.js';
 import { BaseCommand } from '../base.js';
 export default class FilesDownload extends BaseCommand {
     static args = {
-        resourceFile: Args.string({ description: 'Path to a resource file', required: true }),
-        // eslint-disable-next-line perfectionist/sort-objects
-        localDirectory: Args.string({ description: 'Path to save downloaded file', required: true }),
+        resourceFile: Args.string({
+            description: 'Path to a resource file',
+            required: true,
+        }),
+        localDirectory: Args.string({
+            description: 'Path to save downloaded file',
+            required: true,
+        }),
     };
     static description = 'Download file or directory described in resource file';
     static examples = [
@@ -14,7 +19,10 @@ export default class FilesDownload extends BaseCommand {
     ];
     static flags = {
         'maximum-concurrent': Flags.integer({
-            default: 1, description: 'Maximum concurrent pieces to download at once per transfer', max: 1000, min: 1,
+            default: 1,
+            description: 'Maximum concurrent pieces to download at once per transfer',
+            max: 1000,
+            min: 1,
         }),
     };
     static help = 'Download and decrypt a file from the remote storage to <localPath> using resource file <resourcePath>';
@@ -36,7 +44,7 @@ export default class FilesDownload extends BaseCommand {
                 maximumConcurrent: flags['maximum-concurrent'],
                 resourcePath: args.resourceFile,
             }, ({ current, key, total }) => {
-                progress.advance(key, current / total * 100, `Downloading: ${key} [${current}/${total}]`);
+                progress.advance(key, (current / total) * 100, `Downloading: ${key} [${current}/${total}]`);
             });
         }
         catch (error) {