@super-protocol/sp-cli 0.0.2 → 0.0.3

package/bin/dev.js

@@ -2,6 +2,6 @@
 import { execute } from '@oclif/core';
 
 await execute({
-  development: true,
+  development: Boolean(process.env.SP_LOG_LEVEL),
   dir: import.meta.url,
 });

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { BaseCommand } from '../base.js';
+export declare class InfoCommand extends BaseCommand<typeof InfoCommand> {
+    static description: string;
+    init(): Promise<void>;
+    run(): Promise<{
+        address: string;
+        balance: string;
+        storage: {
+            bucket: string;
+            createdAt: string;
+            id: string;
+            isCentralized: boolean;
+            prefix: string;
+            s3Credentials?: import("@super-protocol/provider-client").components["schemas"]["S3CredentialsResponseDto"];
+            storageType: import("@super-protocol/provider-client").components["schemas"]["StorageType"];
+            storjCredentials?: import("@super-protocol/provider-client").components["schemas"]["StorJCredentialsResponseDto"];
+            updatedAt: string;
+            userId: string;
+        };
+        wallet: string;
+    }>;
+}

package/dist/commands/account/info.js

@@ -0,0 +1,46 @@
+import { formatEther } from 'viem';
+import { StorageService } from '../../services/storage.service.js';
+import { BaseCommand } from '../base.js';
+export class InfoCommand extends BaseCommand {
+    static description = 'Information about current authorized user';
+    async init() {
+        await super.init();
+        await this.container.initProviderClient().initAccountManager().initConfigManager().build();
+    }
+    async run() {
+        const { providerClient } = this.container;
+        const storageService = new StorageService(providerClient, this.logger);
+        const { data, error } = await providerClient.GET('/api/auth/me');
+        if (error) {
+            this.error(error.message);
+        }
+        if (!data) {
+            this.error('Failed to retrieve account information');
+        }
+        const { data: wallet } = await providerClient.GET('/api/users/me/wallet');
+        if (!wallet) {
+            this.error('Failed to retrieve wallet information');
+        }
+        const storage = await storageService.getCurrentStorage();
+        const balance = formatEther(BigInt(wallet?.teeBalance || '0'));
+        this.log(`Login: ${data.address}`);
+        this.log(`Super Wallet: ${data.internalAddress}`);
+        this.log(`Balance: ${balance} SPPI`);
+        if (storage.isCentralized) {
+            this.log('Storage: Super cloud');
+        }
+        else {
+            this.log('Active storage:');
+            this.log(`  bucket: ${storage.bucket}`);
+            if (storage.prefix) {
+                this.log(`  prefix: ${storage.prefix}`);
+            }
+        }
+        return {
+            address: data.address,
+            balance,
+            storage,
+            wallet: data.internalAddress,
+        };
+    }
+}

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

@@ -1,17 +1,12 @@
 import { BaseCommand } from '../base.js';
 export default class SpLogin extends BaseCommand<typeof SpLogin> {
+    static aliases: string[];
     static description: string;
     static examples: string[];
-    getTokens(nonce: string): Promise<void>;
-    getUserNonce(address: string): Promise<{
-        error: {
-            message: string;
-            statusCode: number;
-        } | undefined;
-        user: {
-            nonce?: string;
-        } | undefined;
-    }>;
+    checkStorage(): Promise<void>;
     init(): Promise<void>;
-    run(): Promise<void>;
+    run(): Promise<{
+        account: string;
+        success: boolean;
+    }>;
 }

package/dist/commands/auth/login.js

@@ -1,49 +1,22 @@
-import { ux } from '@oclif/core';
+import { AuthService } from '../../services/auth.service.js';
+import { StorageService } from '../../services/storage.service.js';
 import { BaseCommand } from '../base.js';
 export default class SpLogin extends BaseCommand {
-    static description = 'Authorization';
+    static aliases = ['login'];
+    static description = 'Login to SuperProtocol (sign up or sign in).';
     static examples = [
         `<%= config.bin %> <%= command.id %>
 `,
     ];
-    async getTokens(nonce) {
-        const { accountManager, configManager, providerClient } = this.container;
-        const signature = await accountManager.createSign(nonce);
-        const { data: tokenResponse, error, } = await providerClient.POST('/api/auth/token', {
-            body: {
-                address: accountManager.getAddress(),
-                provider: 'sp-cli',
-                signature,
-            },
-        });
-        if (error) {
-            this.logger.error({ err: error }, 'Token exchange failed');
-            ux.error('Authorization failed please try again later.');
-        }
-        const { accessToken } = tokenResponse || {};
-        if (!accessToken) {
-            this.logger.error({ response: tokenResponse }, 'Unexpected token response');
-            ux.error('Provider returned an unexpected token response.');
-        }
-        await configManager.setCredentials({ accessKey: accessToken });
-        this.log('Authorization successful');
-    }
-    async getUserNonce(address) {
+    async checkStorage() {
+        await this.container.initProviderClient({ enableAuth: true, enableCookies: true, rebuild: true }).build();
         const { providerClient } = this.container;
-        try {
-            const { data, error } = await providerClient.GET('/api/users/nonce/{address}', {
-                params: {
-                    path: {
-                        address,
-                    },
-                },
-            });
-            this.logger.debug({ data, error }, 'Getting user nonce');
-            return { error, user: data };
-        }
-        catch (error) {
-            this.logger.error({ err: error }, 'Error request nonce');
-            ux.error('Connection failure, please try again later');
+        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() {
@@ -51,48 +24,27 @@ export default class SpLogin extends BaseCommand {
         await this.container
             .initConfigManager()
             .initAccountManager()
-            .initProviderClient({ enableAuth: false })
+            .initProviderClient({ enableAuth: false, enableCookies: true })
             .build();
     }
     async run() {
-        const { accountManager, providerClient } = this.container;
-        const address = accountManager.getAddress();
-        const { error: nonceError, user } = await this.getUserNonce(address);
-        if (nonceError && nonceError.statusCode === 404) {
-            this.logger.debug('Nonce error call sign up');
-            const { data: nonceResponse, error: signUpError } = await providerClient.POST('/api/auth/sign-up', {
-                body: {
-                    address,
-                },
-            });
-            if (signUpError && signUpError.statusCode === 409) {
-                this.logger.debug({ signUpError }, 'Error signing up');
-                const { error: nonceError, user } = await this.getUserNonce(address);
-                this.logger.debug({ nonceError, user }, 'Requesting nonce again');
-                if (user && user.nonce)
-                    await this.getTokens(user.nonce);
-                else
-                    ux.error('User exists but nonce is unavailable. Please try again or contact support.');
-            }
-            else if (signUpError) {
-                this.logger.error({ signUpError }, 'Sign-up failed');
-                ux.error('Sign-up failed. Please try again later.');
-            }
-            else {
-                const nonce = nonceResponse?.nonce;
-                if (!nonce) {
-                    this.logger.error({ response: nonceResponse }, 'Unexpected sign-up response');
-                    ux.error('Provider did not return a nonce.');
-                }
-                await this.getTokens(nonce);
-            }
+        const { accountManager, configManager, providerClient } = this.container;
+        const authService = new AuthService(accountManager, configManager, providerClient, this.logger);
+        try {
+            await authService.auth();
+        }
+        catch (error) {
+            this.error(error, { exit: 1 });
         }
-        else if (user && user.nonce) {
-            this.logger.debug({ user }, 'Requesting for existed user');
-            await this.getTokens(user.nonce);
+        try {
+            await this.checkStorage();
         }
-        else {
-            ux.error('Unable to retrieve authentication nonce. Please try again later or contact support if the issue persists.');
+        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 };
     }
 }

package/dist/commands/base.d.ts

@@ -4,15 +4,13 @@ import { AppContainer } from '../lib/container.js';
 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 baseFlags: {
-        config: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-        url: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
-    };
+    static baseFlags: typeof Command.baseFlags;
     static enableJsonFlag: boolean;
     protected args: CommandArgs<T>;
     protected container: AppContainer;
     protected flags: CommandFlags<T>;
     protected logger: pino.BaseLogger;
     constructor(argv: string[], config: Config);
+    protected ensurePromptValue<T>(value: symbol | T, errorMessage?: string): T;
     init(): Promise<void>;
 }

package/dist/commands/base.js

@@ -1,3 +1,4 @@
+import { isCancel } from '@clack/prompts';
 import { Command, Flags, } from '@oclif/core';
 import { AppContainer } from '../lib/container.js';
 import logger from '../logger.js';
@@ -8,11 +9,6 @@ export class BaseCommand extends Command {
             required: false,
             summary: 'Specify config file.',
         }),
-        url: Flags.string({
-            helpGroup: 'GLOBAL',
-            required: false,
-            summary: 'Specify provider base URL.',
-        }),
     };
     static enableJsonFlag = true;
     args;
@@ -23,14 +19,17 @@ export class BaseCommand extends Command {
         super(argv, config);
         this.logger = logger.getPino();
     }
+    ensurePromptValue(value, errorMessage = 'Operation cancelled.') {
+        if (isCancel(value)) {
+            this.error(errorMessage);
+        }
+        return value;
+    }
     async init() {
         await super.init();
         const { args, flags } = await this.parse({
             args: this.ctor.args,
-            baseFlags: {
-                ...BaseCommand.baseFlags,
-                ...super.ctor.baseFlags,
-            },
+            baseFlags: super.ctor.baseFlags,
             enableJsonFlag: this.ctor.enableJsonFlag,
             flags: this.ctor.flags,
             strict: this.ctor.strict,
@@ -39,7 +38,6 @@ export class BaseCommand extends Command {
         this.args = args;
         this.container = AppContainer.container.setupRuntimeConfig({
             configFile: flags.config,
-            url: flags.url,
         });
     }
 }

package/dist/commands/config/add.js

@@ -48,7 +48,6 @@ export default class ConfigAdd extends BaseConfigCommand {
                     if (!existsSync(testPath)) {
                         return 'File does not exist';
                     }
-                    return true;
                 },
             });
         }
@@ -65,17 +64,7 @@ export default class ConfigAdd extends BaseConfigCommand {
             const displayName = importedConfig?.name || importedFileName;
             this.log(`Successfully imported configuration: ${displayName}`);
             this.log(`Configuration file: ${importedFileName}`);
-            const shouldSwitch = this.flags.yes || await this.selectPrompt({
-                choices: [
-                    { name: 'Yes', value: true },
-                    { name: 'No', value: false },
-                ],
-                message: 'Switch to this configuration now?',
-            });
-            if (shouldSwitch) {
-                await this.configFileManager.setCurrentConfig(importedFileName);
-                this.log(`Switched to configuration: ${displayName}`);
-            }
+            await this.switchToNewConfig(importedFileName, displayName, this.flags.yes);
         }
         catch (error) {
             this.error(`Failed to import configuration: ${error instanceof Error ? error.message : String(error)}`);

package/dist/commands/config/base.d.ts

@@ -1,14 +1,16 @@
 import type { Command } from '@oclif/core';
-import { input, select } from '@inquirer/prompts';
+import { select, text } from '@clack/prompts';
 import type { ConfigFileManager } from '../../managers/config-file-manager.js';
 import { BaseCommand } from '../base.js';
-type InputOptions = Parameters<typeof input>[0];
+type TextOptions = Parameters<typeof text>[0];
 type SelectOptions<T> = Parameters<typeof select<T>>[0];
 export declare abstract class BaseConfigCommand<T extends typeof Command> extends BaseCommand<T> {
+    static baseFlags: {};
     protected configFileManager: ConfigFileManager;
     protected displayCurrentConfig(): void;
     init(): Promise<void>;
-    protected inputPrompt(options: InputOptions): Promise<string>;
+    protected inputPrompt(options: TextOptions): Promise<string>;
     protected selectPrompt<Value>(options: SelectOptions<Value>): Promise<Value>;
+    protected switchToNewConfig(configFile: string, displayName: string, yes: boolean): Promise<void>;
 }
 export {};

package/dist/commands/config/base.js

@@ -1,6 +1,8 @@
-import { input, select } from '@inquirer/prompts';
+import { select, text } from '@clack/prompts';
+import { PROVIDER_URL } from '../../constants.js';
 import { BaseCommand } from '../base.js';
 export class BaseConfigCommand extends BaseCommand {
+    static baseFlags = {};
     configFileManager;
     displayCurrentConfig() {
         const current = this.configFileManager.getCurrentConfigFile();
@@ -20,25 +22,19 @@ export class BaseConfigCommand extends BaseCommand {
                     this.log(`  Provider URL: ${configData.providerUrl}`);
                 }
                 else {
-                    this.log('  Provider URL: (using default)');
+                    this.log(`  Provider URL: ${PROVIDER_URL} (using default)`);
                 }
                 if (configData.auth?.accessKey) {
-                    this.log('  Authorization: ✓ Configured');
+                    this.log('  Authorization: Configured');
                 }
                 else {
-                    this.log('  Authorization: ✗ Not configured');
+                    this.log('  Authorization: Unauthorized');
                 }
                 if (configData.account?.address) {
-                    this.log(`  Account: ✓ ${configData.account.address}`);
+                    this.log(`  Account: ${configData.account.address}`);
                 }
                 else {
-                    this.log('  Account: ✗ Not configured');
-                }
-                if (configData.cookies) {
-                    this.log('  Cookies: ✓ Stored');
-                }
-                else {
-                    this.log('  Cookies: ✗ None');
+                    this.log('  Account: Not configured');
                 }
             }
         }
@@ -54,9 +50,29 @@ export class BaseConfigCommand extends BaseCommand {
         this.configFileManager = this.container.configFileManager;
     }
     async inputPrompt(options) {
-        return input(options);
+        const result = await text(options);
+        return this.ensurePromptValue(result);
     }
     async selectPrompt(options) {
-        return select(options);
+        const result = await select(options);
+        return this.ensurePromptValue(result);
+    }
+    async switchToNewConfig(configFile, displayName, yes) {
+        const shouldSwitch = yes || await this.selectPrompt({
+            message: 'Switch to this configuration now?',
+            options: [
+                { label: 'Yes', value: true },
+                { label: 'No', value: false },
+            ],
+        });
+        if (shouldSwitch) {
+            await this.configFileManager.setCurrentConfig(configFile);
+            this.log(`Switched to configuration: ${displayName}`);
+            await this.container
+                .initConfigFileManager(true)
+                .initConfigManager(true)
+                .initAccountManager(true)
+                .build();
+        }
     }
 }

package/dist/commands/config/create.js

@@ -32,17 +32,7 @@ export default class ConfigCreate extends BaseConfigCommand {
             if (url) {
                 this.log(`Provider URL: ${url}`);
             }
-            const shouldSwitch = yes || await this.selectPrompt({
-                choices: [
-                    { name: 'Yes', value: true },
-                    { name: 'No', value: false },
-                ],
-                message: 'Switch to this configuration now?',
-            });
-            if (shouldSwitch) {
-                await this.configFileManager.setCurrentConfig(fileName);
-                this.log(`Switched to configuration: ${name}`);
-            }
+            await this.switchToNewConfig(fileName, name, yes);
         }
         catch (error) {
             this.error(`Failed to create configuration: ${error instanceof Error ? error.message : String(error)}`);

package/dist/commands/config/list.js

@@ -1,3 +1,5 @@
+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';
@@ -12,28 +14,27 @@ export default class ConfigList extends BaseConfigCommand {
             this.log('Create a new configuration with: sp config create --name "Config Name"');
             return;
         }
-        this.log('Available configurations:\n');
+        const rows = [];
         for (const config of configs) {
             const marker = config.file === current ? '* ' : '  ';
             const configData = this.configFileManager.getConfigData(config.file);
-            let statusInfo = '';
-            if (configData) {
-                const parts = [];
-                if (configData.providerUrl) {
-                    parts.push(`URL: ${configData.providerUrl}`);
-                }
-                if (configData.auth) {
-                    parts.push('Auth: ✓');
-                }
-                if (configData.account) {
-                    parts.push('Account: ✓');
-                }
-                if (parts.length > 0) {
-                    statusInfo = ` | ${parts.join(', ')}`;
-                }
-            }
-            this.log(`${marker}${config.name}${statusInfo}`);
-            this.log(`  File: ${config.file}`);
+            const row = {
+                account: configData?.account?.address ?? '[not found in config file]',
+                current: marker,
+                file: config.file,
+                name: config.name,
+                url: configData?.providerUrl ?? PROVIDER_URL,
+            };
+            rows.push(row);
         }
+        printTable(rows, {
+            columns: [
+                { name: 'current', title: 'Current' },
+                { name: 'name', title: 'Config name' },
+                { name: 'account', title: 'Account' },
+                { name: 'url', title: 'Provider Url' },
+                { name: 'file', title: 'Configuration File' },
+            ], title: 'Available configurations',
+        });
     }
 }

package/dist/commands/config/use.js

@@ -6,17 +6,19 @@ export default class ConfigUse extends BaseConfigCommand {
     ];
     async run() {
         const configs = this.configFileManager.getConfigsWithNames();
+        const currentConfig = 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"');
             return;
         }
         const selected = await this.selectPrompt({
-            choices: configs.map(config => ({
-                name: config.name ?? config.file,
+            initialValue: currentConfig,
+            message: 'Select a configuration:',
+            options: configs.map(config => ({
+                label: config.name ?? config.file,
                 value: config.file,
             })),
-            message: 'Select a configuration:',
         });
         await this.configFileManager.setCurrentConfig(selected);
         const selectedConfig = configs.find(c => c.file === selected);

package/dist/commands/files/download.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../base.js';
+export default class FilesDownload extends BaseCommand<typeof FilesDownload> {
+    static args: {
+        resourceFile: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        localDirectory: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'maximum-concurrent': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static help: string;
+    init(): Promise<void>;
+    run(): Promise<void>;
+}

package/dist/commands/files/download.js

@@ -0,0 +1,55 @@
+import { Args, Flags } from '@oclif/core';
+import { StorageService } from '../../services/storage.service.js';
+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 }),
+    };
+    static description = 'Download file or directory described in resource file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./resource.json ./pathToDownload ',
+    ];
+    static flags = {
+        'maximum-concurrent': Flags.integer({
+            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>';
+    async init() {
+        await super.init();
+        await this.container.initProviderClient({ enableAuth: false }).initConfigManager().build();
+    }
+    async run() {
+        const { args, flags } = await this.parse(FilesDownload);
+        const { providerClient } = this.container;
+        const storageService = new StorageService(providerClient, this.logger);
+        const progress = createProgressPrinter({
+            action: 'Download',
+            start: 'Downloading: ',
+        });
+        try {
+            await storageService.download({
+                downloadPath: args.localDirectory,
+                maximumConcurrent: flags['maximum-concurrent'],
+                resourcePath: args.resourceFile,
+            }, ({ current, key, total }) => {
+                progress.advance(key, current / total * 100, `Downloading: ${key} [${current}/${total}]`);
+            });
+        }
+        catch (error) {
+            let reason = '';
+            this.logger.error({ err: error }, 'Error trying download');
+            if (error instanceof Error) {
+                reason = error.message;
+            }
+            this.error(`Download aborted. Reason: ${reason}`);
+        }
+        finally {
+            progress.finish();
+        }
+        this.log('Download successfully completed');
+    }
+}

package/dist/commands/files/upload.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../base.js';
+export default class FilesUpload extends BaseCommand<typeof FilesUpload> {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        filename: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'maximum-concurrent': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        metadata: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'skip-encryption': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        sync: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    run(): Promise<void>;
+}