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

package/dist/lib/container.js

@@ -17,7 +17,6 @@ export class AppContainer {
     initQueue = new Map();
     logger;
     runtimeConfigFile;
-    runtimeProviderUrl;
     constructor(cwdDir, oclifConfig) {
         this.cwdDir = cwdDir;
         this.oclifConfig = oclifConfig;
@@ -61,9 +60,10 @@ export class AppContainer {
     }
     async build() {
         await Promise.all(this.initPromises);
+        return this;
     }
-    initAccountManager() {
-        this.initConfigManager();
+    initAccountManager(rebuild = true) {
+        this.initConfigManager(rebuild);
         return this.queueInit('accountManager', async () => {
             await this.waitFor('configManager');
             if (this._accountManager) {
@@ -73,9 +73,9 @@ export class AppContainer {
             const accountManager = new AccountManager(this.configManager, this.logger);
             await accountManager.init();
             this._accountManager = accountManager;
-        });
+        }, rebuild);
     }
-    initConfigFileManager() {
+    initConfigFileManager(rebuild = false) {
         return this.queueInit('configFileManager', async () => {
             if (this._configFileManager) {
                 return;
@@ -85,10 +85,10 @@ export class AppContainer {
             });
             await configFileManager.init();
             this._configFileManager = configFileManager;
-        });
+        }, rebuild);
     }
-    initConfigManager() {
-        this.initConfigFileManager();
+    initConfigManager(rebuild = false) {
+        this.initConfigFileManager(rebuild);
         return this.queueInit('configManager', async () => {
             await this.waitFor('configFileManager');
             if (this._configManager) {
@@ -102,22 +102,32 @@ export class AppContainer {
             const configManager = new ConfigManager(configFilePath, this.logger);
             await configManager.init();
             this._configManager = configManager;
-        });
+        }, rebuild);
     }
-    initProviderClient({ enableAuth = true, enableCookies = true } = {}) {
+    initProviderClient({ enableAuth = true, enableCookies = true, rebuild = false } = {}) {
         this.initConfigManager();
         return this.queueInit('providerClient', async () => {
-            if (this._providerClient) {
+            if (this._providerClient && !rebuild) {
                 return;
             }
             await this.waitFor('configManager');
-            const providerUrl = this.runtimeProviderUrl || await this.configManager.get('providerUrl') || PROVIDER_URL;
+            const providerUrl = await this.configManager.get('providerUrl') || PROVIDER_URL;
             this.logger.info('Initializing provider client');
             const providerClient = createProviderClient({
                 baseUrl: providerUrl,
                 logger: this.logger,
                 middlewares: [requestIdMiddleware, loggerMiddleware],
             });
+            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);
+            }
             providerClient.use({
                 onRequest: async ({ request }) => {
                     const req = request.clone();
@@ -128,28 +138,18 @@ export class AppContainer {
                     }
                     this.logger.debug({
                         body,
+                        token: req.headers.get('Authorization'),
                         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;
-        });
+        }, rebuild);
     }
     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
@@ -160,8 +160,8 @@ export class AppContainer {
         }
         return this;
     }
-    queueInit(name, task) {
-        if (!this.initQueue.has(name)) {
+    queueInit(name, task, force = false) {
+        if (!this.initQueue.has(name) || force) {
             const promise = task();
             this.initQueue.set(name, promise);
             this.initPromises.push(promise);

package/dist/managers/account-manager.js

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { confirm, password } from '@inquirer/prompts';
+import { confirm, isCancel, password } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
+import { Value } from 'typebox/value';
 import { Retryable } from 'typescript-retry-decorator';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { accountSchema } from '../config/config.schema.js';
@@ -69,6 +69,9 @@ export class AccountManager {
             const ask = await confirm({
                 message: 'Do you want to create new one?',
             });
+            if (isCancel(ask)) {
+                ux.error('Operation cancelled.', { exit: 1 });
+            }
             if (ask) {
                 await this.promptAccount();
             }
@@ -81,8 +84,15 @@ export class AccountManager {
         const askPrivateKey = await confirm({
             message: 'Do you want to input privateKey?',
         });
+        if (isCancel(askPrivateKey)) {
+            ux.error('Operation cancelled.', { exit: 1 });
+        }
         if (askPrivateKey) {
-            const privateKey = await password({ message: 'Please input your privateKey for using in account' });
+            const privateKeyInput = await password({ message: 'Please input your privateKey for using in account' });
+            if (isCancel(privateKeyInput)) {
+                ux.error('Operation cancelled.', { exit: 1 });
+            }
+            const privateKey = privateKeyInput.trim();
             try {
                 const account = await this.createFromKey(privateKey);
                 ux.stdout('Your privateKey will be used in config. Keypair created');

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

@@ -1,4 +1,4 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
 import pino from 'pino';
 import { CliConfig } from '../config/config.schema.js';

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

@@ -1,8 +1,8 @@
-import { confirm, select } from '@inquirer/prompts';
+import { confirm, isCancel, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
 import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
 import { getConfigName } from '../utils/helper.js';
@@ -78,22 +78,27 @@ export class ConfigFileManager {
             configToDelete = config.file;
         }
         else {
-            configToDelete = await this.selectPrompt({
-                choices: configs.map(config => ({
-                    name: config.name,
+            const selection = await this.selectPrompt({
+                message: 'Select configuration to delete:',
+                options: configs.map(config => ({
+                    label: config.name,
                     value: config.file,
                 })),
-                message: 'Select configuration to delete:',
             });
+            if (isCancel(selection)) {
+                this.ux.stdout('Deletion cancelled');
+                return;
+            }
+            configToDelete = selection;
         }
         const configToDeleteData = configs.find(c => c.file === configToDelete);
         const displayName = configToDeleteData?.name || configToDelete;
         if (!force) {
             const confirmed = await this.confirmPrompt({
-                default: false,
+                initialValue: false,
                 message: `Are you sure you want to delete configuration "${displayName}"?`,
             });
-            if (!confirmed) {
+            if (isCancel(confirmed) || !confirmed) {
                 this.ux.stdout('Deletion cancelled');
                 return;
             }

package/dist/middlewares/auth-middleware.js

@@ -1,4 +1,5 @@
 import { decode } from 'jsonwebtoken';
+import { REFRESH_TOKEN_URI } from '../constants.js';
 import { AuthorizationRequiredError } from '../errors.js';
 function isAccessKeyExpired(accessKey) {
     try {
@@ -23,7 +24,7 @@ export async function createAuthMiddleware(configManager, providerClient, logger
         logger.info('Performed refresh token');
         let refreshResult;
         try {
-            refreshResult = await providerClient.POST('/api/auth/refresh-access');
+            refreshResult = await providerClient.POST(REFRESH_TOKEN_URI);
         }
         catch (error) {
             logger.error({ err: error }, 'failure refresh token');
@@ -76,6 +77,9 @@ export async function createAuthMiddleware(configManager, providerClient, logger
     }
     const middleware = {
         async onRequest({ request }) {
+            if (request.url.endsWith(REFRESH_TOKEN_URI)) {
+                return request;
+            }
             const accessToken = await ensureAccessKey();
             if (accessToken) {
                 request.headers.set('Authorization', `Bearer ${accessToken}`);

package/dist/services/auth.service.d.ts

@@ -0,0 +1,24 @@
+import { ProviderClient } from '@super-protocol/provider-client';
+import pino from 'pino';
+import { AccountManager } from '../managers/account-manager.js';
+import { ConfigManager } from '../managers/config-manager.js';
+export declare class AuthError extends Error {
+}
+export declare class AuthService {
+    private readonly accountManager;
+    private readonly configManager;
+    private readonly providerClient;
+    private readonly logger;
+    constructor(accountManager: AccountManager, configManager: ConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
+    auth(): Promise<void>;
+    getTokens(nonce: string): Promise<void>;
+    getUserNonce(address: string): Promise<{
+        error: {
+            message: string;
+            statusCode: number;
+        } | undefined;
+        user: {
+            nonce?: string;
+        } | undefined;
+    }>;
+}

package/dist/services/auth.service.js

@@ -0,0 +1,93 @@
+export class AuthError extends Error {
+}
+export class AuthService {
+    accountManager;
+    configManager;
+    providerClient;
+    logger;
+    constructor(accountManager, configManager, providerClient, logger) {
+        this.accountManager = accountManager;
+        this.configManager = configManager;
+        this.providerClient = providerClient;
+        this.logger = logger;
+    }
+    async auth() {
+        const address = this.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 this.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 {
+                    throw new AuthError('User exists but nonce is unavailable. Please try again or contact support.');
+                }
+            }
+            else if (signUpError) {
+                this.logger.error({ signUpError }, 'Sign-up failed');
+                throw new AuthError('Sign-up failed. Please try again later.');
+            }
+            else {
+                const nonce = nonceResponse?.nonce;
+                if (!nonce) {
+                    this.logger.error({ response: nonceResponse }, 'Unexpected sign-up response');
+                    throw new AuthError('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);
+        }
+        else {
+            throw new AuthError('Unable to retrieve authentication nonce. Please try again later or contact support if the issue persists.');
+        }
+    }
+    async getTokens(nonce) {
+        const signature = await this.accountManager.createSign(nonce);
+        const { data: tokenResponse, error, } = await this.providerClient.POST('/api/auth/token', {
+            body: {
+                address: this.accountManager.getAddress(),
+                provider: 'sp-cli',
+                signature,
+            },
+        });
+        if (error) {
+            this.logger.error({ err: error }, 'Token exchange failed');
+            throw new AuthError(error.message);
+        }
+        const { accessToken } = tokenResponse || {};
+        if (!accessToken) {
+            this.logger.error({ response: tokenResponse }, 'Unexpected token response');
+            throw new AuthError('Provider returned an unexpected token response.');
+        }
+        await this.configManager.setCredentials({ accessKey: accessToken });
+    }
+    async getUserNonce(address) {
+        try {
+            const { data, error } = await this.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');
+            throw new AuthError('Connection failure, please try again later');
+        }
+    }
+}

package/dist/services/storage.service.d.ts

@@ -0,0 +1,71 @@
+import { EncryptionWithIV, Resource, RuntimeInputInfo } from '@super-protocol/dto-js';
+import { AddStorageDto, ProviderClient, StorageResponseDto, UpdateStorageDto } from '@super-protocol/provider-client';
+import pino from 'pino';
+export declare class StorageError extends Error {
+}
+export declare class StoragesUndefinedError extends StorageError {
+}
+export declare class StorageCreateError extends StorageError {
+}
+export declare class StorageUpdateError extends StorageError {
+}
+export declare class StorageGetError extends StorageError {
+}
+type IUploadParams = {
+    localPath: string;
+    maximumConcurrent?: number;
+    metadataPath?: string;
+    outputPath?: string;
+    remotePath?: string;
+    sync?: boolean;
+    withEncryption: boolean;
+};
+type IDownloadParams = {
+    downloadPath: string;
+    maximumConcurrent?: number;
+    resourcePath: string;
+};
+export type ResourceFile = Partial<Pick<RuntimeInputInfo, 'args' | 'hardwareContext' | 'hash' | 'signatureKeyHash'>> & {
+    encryption?: EncryptionWithIV;
+    resource: Resource;
+};
+type ProgressCb = (arg: {
+    current: number;
+    key: string;
+    total: number;
+}) => void;
+export declare const generateExternalId: () => string;
+export declare class StorageService {
+    private readonly providerClient;
+    private readonly logger;
+    constructor(providerClient: ProviderClient, logger: pino.BaseLogger);
+    createStorage(storage: AddStorageDto): Promise<StorageResponseDto>;
+    download(params: IDownloadParams, progressCb: ProgressCb): Promise<void>;
+    getCentralizedStorage(): Promise<StorageResponseDto>;
+    getCurrentStorage(): Promise<StorageResponseDto>;
+    hasStorage(): Promise<boolean>;
+    initCentralizedStorage(): Promise<{
+        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;
+    }>;
+    requestStorages(): Promise<StorageResponseDto[]>;
+    saveStorage(selectedStorage: string): Promise<{
+        activeStorageId: string;
+        createdAt: string;
+        decentralizedStorageId?: string;
+        id: string;
+        updatedAt: string;
+        userId: string;
+    }>;
+    updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
+    upload(params: IUploadParams, progressCb: ProgressCb): Promise<void>;
+}
+export {};