@super-protocol/sp-cli 0.0.2-beta.1 → 0.0.2-beta.11

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

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../base.js';
+export declare class InfoCommand extends BaseCommand<typeof InfoCommand> {
+    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,43 @@
+import { formatEther } from 'viem';
+import { StorageService } from '../../services/storage.service.js';
+import { BaseCommand } from '../base.js';
+export class InfoCommand extends BaseCommand {
+    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'), 'wei');
+        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}`);
+            this.log(`  prefix: ${storage.prefix}`);
+        }
+        return {
+            address: data.address,
+            balance,
+            storage,
+            wallet: data.internalAddress,
+        };
+    }
+}

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

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

package/dist/commands/auth/login.js

@@ -1,7 +1,8 @@
-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 aliases = ['login'];
     static description = 'Authorization';
     static examples = [
         `<%= config.bin %> <%= command.id %>
@@ -9,53 +10,13 @@ export default class SpLogin extends BaseCommand {
     ];
     async checkStorage() {
         await this.container.initProviderClient({ enableAuth: true, enableCookies: true, rebuild: true }).build();
-        const { configManager, providerClient } = this.container;
-        const storageService = new StorageService(configManager, providerClient, this.logger);
+        const { providerClient } = this.container;
+        const storageService = new StorageService(providerClient, this.logger);
         if (!await storageService.hasStorage()) {
             this.logger.info('Requesting default storage');
-            const storage = await storageService.initStorage();
-            this.logger.info({ storage }, 'Requested new storage');
-            await storageService.saveStorage(storage.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) {
-        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 { id, isCentralized, storageType } = await storageService.getCentralizedStorage();
+            this.logger.info({ id, isCentralized, storageType }, 'Requested new storage');
+            await storageService.saveStorage(id);
         }
     }
     async init() {
@@ -63,48 +24,17 @@ 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);
-            }
-        }
-        else if (user && user.nonce) {
-            this.logger.debug({ user }, 'Requesting for existed user');
-            await this.getTokens(user.nonce);
+        const { accountManager, configManager, providerClient } = this.container;
+        const authService = new AuthService(accountManager, configManager, providerClient, this.logger);
+        try {
+            await authService.auth();
         }
-        else {
-            ux.error('Unable to retrieve authentication nonce. Please try again later or contact support if the issue persists.');
+        catch (error) {
+            this.error(error, { exit: 1 });
         }
         try {
             await this.checkStorage();
@@ -113,5 +43,6 @@ export default class SpLogin extends BaseCommand {
             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".');
         }
+        this.log('Successfully authorized');
     }
 }

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;
                 },
             });
         }
@@ -66,15 +65,20 @@ export default class ConfigAdd extends BaseConfigCommand {
             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?',
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
             });
             if (shouldSwitch) {
                 await this.configFileManager.setCurrentConfig(importedFileName);
                 this.log(`Switched to configuration: ${displayName}`);
+                await this.container
+                    .initConfigFileManager(true)
+                    .initConfigManager(true)
+                    .initAccountManager(true)
+                    .build();
             }
         }
         catch (error) {

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

@@ -1,14 +1,15 @@
 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>;
 }
 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: [OK] Configured');
                 }
                 else {
-                    this.log('  Authorization: ✗ Not configured');
+                    this.log('  Authorization: [--] Not configured');
                 }
                 if (configData.account?.address) {
-                    this.log(`  Account: ✓ ${configData.account.address}`);
+                    this.log(`  Account: [OK] ${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,11 @@ 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);
     }
 }

package/dist/commands/config/create.js

@@ -33,11 +33,11 @@ export default class ConfigCreate extends BaseConfigCommand {
                 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?',
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
             });
             if (shouldSwitch) {
                 await this.configFileManager.setCurrentConfig(fileName);

package/dist/commands/config/list.js

@@ -23,10 +23,10 @@ export default class ConfigList extends BaseConfigCommand {
                     parts.push(`URL: ${configData.providerUrl}`);
                 }
                 if (configData.auth) {
-                    parts.push('Auth: ✓');
+                    parts.push('Auth: [OK]');
                 }
                 if (configData.account) {
-                    parts.push('Account: ✓');
+                    parts.push(`Account: [OK] ${configData.account.address} `);
                 }
                 if (parts.length > 0) {
                     statusInfo = ` | ${parts.join(', ')}`;

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,53 @@
+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 = 'describe the command here';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./resource.json ./pathToDownload ',
+    ];
+    static flags = {
+        'maximum-concurrent': Flags.integer({
+            default: 1, description: 'Maximum concurrent pieces to upload 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 storageSerivce = new StorageService(providerClient, this.logger);
+        const progress = createProgressPrinter({
+            action: 'Download',
+            start: 'Downloading: ',
+        });
+        try {
+            await storageSerivce.download({
+                downloadPath: args.localDirectory,
+                maximumConcurrent: flags['maximum-concurrent'],
+                resourcePath: args.resourceFile,
+            }, ({ current, key, total }) => {
+                progress.advance(key, current / total * 100, `Downloading: ${key} [${current}/${total}]`);
+            });
+            progress.finish();
+        }
+        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}`);
+        }
+        this.log('Download successful 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>;
+}

package/dist/commands/files/upload.js

@@ -0,0 +1,77 @@
+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 FilesUpload extends BaseCommand {
+    static args = {
+        path: Args.string({ description: 'file or directory to upload', required: true }),
+    };
+    static description = 'describe the command here';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> ./file.txt',
+    ];
+    static flags = {
+        filename: Flags.string({
+            description: 'The name of the resulting file/directory in the storage',
+            required: false,
+        }),
+        'maximum-concurrent': Flags.integer({
+            default: 1, description: 'Maximum concurrent pieces to upload at once per transfer', max: 1000, min: 1,
+        }),
+        metadata: Flags.string({
+            description: 'Path to a metadata file for adding fields to the resource file',
+            required: false,
+        }),
+        output: Flags.string({
+            default: 'resource.json',
+            description: 'Path to save resource file that is used to access the uploaded file',
+            required: false,
+        }),
+        'skip-encryption': Flags.boolean({
+            default: false,
+            description: 'Skip file encryption before upload',
+            required: false,
+        }),
+        sync: Flags.boolean({
+            default: false,
+            description: 'Sync mode: delete files in target that don\'t exist in source',
+            required: false,
+        }),
+    };
+    async init() {
+        await super.init();
+        await this.container.initProviderClient().initConfigManager().build();
+    }
+    async run() {
+        const { args, flags } = await this.parse(FilesUpload);
+        const { providerClient } = this.container;
+        const storageSerivce = new StorageService(providerClient, this.logger);
+        const progress = createProgressPrinter({
+            action: 'Upload',
+            start: 'Uploading: ',
+        });
+        try {
+            await storageSerivce.upload({
+                localPath: args.path,
+                maximumConcurrent: flags['maximum-concurrent'],
+                metadataPath: flags.metadata,
+                outputPath: flags.output,
+                remotePath: flags.filename,
+                sync: flags.sync,
+                withEncryption: flags['skip-encryption'],
+            }, ({ current, key, total }) => {
+                progress.advance(key, current / total * 100, `Uploading: ${key} [${current}/${total}]`);
+            });
+            progress.finish();
+        }
+        catch (error) {
+            let reason = '';
+            this.logger.error({ err: error }, 'Error trying upload');
+            if (error instanceof Error) {
+                reason = error.message;
+            }
+            this.error(`Upload aborted. Reason: ${reason}`);
+        }
+        this.log('Upload successful completed');
+    }
+}

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

@@ -1,8 +1,13 @@
 import { Command } from '@oclif/core';
+import { AddStorageDto } from '@super-protocol/provider-client';
 import { BaseCommand } from '../../commands/base.js';
 import { StorageService } from '../../services/storage.service.js';
 export declare abstract class BaseStorageCommand<T extends typeof Command> extends BaseCommand<T> {
     protected currentDir: string;
     protected storageService: StorageService;
     init(): Promise<void>;
+    protected promptS3Credentials(): Promise<NonNullable<AddStorageDto['s3Credentials']>>;
+    protected promptStoragePayload(): Promise<AddStorageDto>;
+    protected promptStorJCredentials(): Promise<NonNullable<AddStorageDto['storjCredentials']>>;
+    protected validateStoragePayload(payload: Partial<AddStorageDto> | undefined): asserts payload is AddStorageDto;
 }