@super-protocol/sp-cli 0.0.2 → 0.0.4

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,73 @@
+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>;
+    getLabel(storage: StorageResponseDto): string;
+    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;
+    } | undefined>;
+    updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
+    upload(params: IUploadParams, progressCb: ProgressCb): Promise<void>;
+    private getStorageCredentials;
+}
+export {};

package/dist/services/storage.service.js

@@ -0,0 +1,351 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { StorageResourceSchema, StorageType, } from '@super-protocol/dto-js';
+import { ResourceType, } from '@super-protocol/provider-client';
+import { download, upload } from '@super-protocol/sp-files-addon';
+import * as fs from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
+import { Value } from 'typebox/value';
+import { Retryable } from 'typescript-retry-decorator';
+import { S3_ENDPOINT } from '../constants.js';
+import { ProviderClientError } from '../errors.js';
+import { joinPaths, preparePath, readJsonFile } from '../utils/helper.js';
+export class StorageError extends Error {
+}
+export class StoragesUndefinedError extends StorageError {
+}
+export class StorageCreateError extends StorageError {
+}
+export class StorageUpdateError extends StorageError {
+}
+export class StorageGetError extends StorageError {
+}
+export const generateExternalId = () => Array.from({ length: 16 }).map(() => Math.floor(Math.random() * 16).toString(16)).join('');
+export class StorageService {
+    providerClient;
+    logger;
+    constructor(providerClient, logger) {
+        this.providerClient = providerClient;
+        this.logger = logger;
+    }
+    async createStorage(storage) {
+        this.logger.info({ storageType: storage.storageType }, 'Creating storage');
+        try {
+            const { data, error } = await this.providerClient.POST('/api/storages', {
+                body: storage,
+            });
+            if (error && error.message) {
+                this.logger.error({ err: error }, 'Failed to create storage');
+                throw new StorageCreateError(error.message);
+            }
+            if (!data) {
+                this.logger.error('Provider returned empty storage response');
+                throw new StorageCreateError('Incorrect response');
+            }
+            this.logger.info({ storageId: data.id }, 'Storage created successfully');
+            return data;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Storage creation failed');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async download(params, progressCb) {
+        const resourceFile = await readJsonFile({ path: params.resourcePath });
+        if (!Value.Check(StorageResourceSchema, resourceFile)) {
+            throw new StorageError('Invalid resource file format, please verify resource.json against the schema.');
+        }
+        const { resource } = resourceFile;
+        if (resource.type !== ResourceType.StorageProvider) {
+            throw new StorageError(`Resource type ${resource.type} is not supported, use StorageProvider type for this command`);
+        }
+        let localPath = preparePath(params.downloadPath);
+        if (resource.filepath) {
+            const sanitizedFilepath = resource.filepath.replaceAll('..', '').replace(/^\/+/, '');
+            localPath = joinPaths(localPath, sanitizedFilepath);
+        }
+        try {
+            this.logger.info('Starting download');
+            const downloadResult = await download(resource, localPath, {
+                encryption: resourceFile.encryption,
+                progressCallback: progressCb,
+                retry: {
+                    initialDelayMs: 0,
+                    maxRetries: 2,
+                },
+                threads: params.maximumConcurrent,
+            });
+            this.logger.info(downloadResult, 'Downloaded');
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Download failed with error');
+            throw error;
+        }
+    }
+    async getCentralizedStorage() {
+        try {
+            const storages = await this.requestStorages();
+            const centralized = storages.find(storage => storage.isCentralized);
+            if (!centralized) {
+                const storage = await this.initCentralizedStorage();
+                return storage;
+            }
+            return centralized;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Error getting centralized storage');
+            if (error instanceof StoragesUndefinedError) {
+                const storage = await this.initCentralizedStorage();
+                return storage;
+            }
+            throw error;
+        }
+    }
+    async getCurrentStorage() {
+        try {
+            const { data, error } = await this.providerClient.GET('/api/user-settings');
+            if (error) {
+                throw new StorageGetError('Error getting storage');
+            }
+            const { activeStorageId } = data || {};
+            const storages = await this.requestStorages();
+            const storage = storages.find(storage => storage.id === activeStorageId);
+            if (!storage) {
+                throw new StorageError('Selected storage not found please select storage first');
+            }
+            return storage;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Failed to get current storage');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    getLabel(storage) {
+        return `${storage.isCentralized ? 'Super cloud' : `${storage.storageType} - ${storage.bucket}/${storage.prefix}`} `;
+    }
+    async hasStorage() {
+        try {
+            const { data, error } = await this.providerClient.GET('/api/user-settings');
+            if (error && error.statusCode === 404) {
+                return false;
+            }
+            if (error) {
+                this.logger.error({ err: error }, 'Error checking storage');
+                throw new StorageError(`Error request storage ${error}`);
+            }
+            if (!data) {
+                throw new StorageError('Error request storage');
+            }
+            return Boolean(data.activeStorageId);
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Storage initialization failed');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async initCentralizedStorage() {
+        this.logger.info('Requesting storage initialization');
+        try {
+            const result = await this.providerClient.POST('/api/storages/centralized');
+            if (result.error) {
+                this.logger.error({ err: result.error }, 'Failed to initialize storage');
+                throw new StorageCreateError(result.error.message);
+            }
+            if (!result.data) {
+                this.logger.error('Provider returned empty storage initialization response');
+                throw new StorageCreateError('Incorrect response');
+            }
+            this.logger.info('Storage initialized successfully');
+            return result.data;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Storage initialization failed');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async requestStorages() {
+        let data;
+        this.logger.info('Requesting available storages');
+        try {
+            const result = await this.providerClient.GET('/api/storages');
+            data = result.data;
+            if (result.error) {
+                this.logger.error({ err: result.error }, 'Failed to fetch storages');
+                throw new StorageError(result.error.message);
+            }
+            if (data === undefined) {
+                this.logger.warn('Storages list response is wrong');
+                throw new StoragesUndefinedError('Storages is empty please create or import first one');
+            }
+            this.logger.debug({ count: data.length }, 'Received storages list');
+            return data;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Failed to request storages');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async saveStorage(selectedStorage) {
+        this.logger.info({ selectedStorage }, 'Saving selected storage');
+        try {
+            let { data, error } = await this.providerClient.PATCH('/api/user-settings', {
+                body: {
+                    activeStorageId: selectedStorage,
+                },
+            });
+            if (error && error.statusCode === 404) {
+                const result = await this.providerClient.POST('/api/user-settings', {
+                    body: {
+                        activeStorageId: selectedStorage,
+                    },
+                });
+                error = result.error;
+                data = result.data;
+            }
+            if (error) {
+                throw new StorageError(`User settings request error ${error.message}`);
+            }
+            this.logger.info({ selectedStorage: data?.activeStorageId }, 'Selected storage saved successfully');
+            return data;
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Failed to save selected storage');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async updateStorage(id, storage) {
+        this.logger.info({ storageId: id }, 'Updating storage');
+        try {
+            const { data, error } = await this.providerClient.PATCH('/api/storages/{id}', {
+                body: storage,
+                params: { path: { id } },
+            });
+            if (error) {
+                this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
+                throw new StorageUpdateError(error.message);
+            }
+            if (!data) {
+                this.logger.error({ storageId: id }, 'Provider returned empty storage update response');
+                throw new StorageUpdateError('Incorrect response');
+            }
+            this.logger.info({ storageId: data.id }, 'Storage updated successfully');
+            return data;
+        }
+        catch (error) {
+            this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
+    async upload(params, progressCb) {
+        const storage = await this.getCurrentStorage();
+        const remotePath = params.remotePath ? params.remotePath.replaceAll('..', '').replace(/^\/+/, '') : generateExternalId();
+        const resourceFilePath = preparePath(params.outputPath ?? 'resource.json');
+        try {
+            await fs.stat(resourceFilePath);
+            throw new Error('Output file for resource file already exists');
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        let metadata = {};
+        if (params.metadataPath) {
+            metadata = await readJsonFile({ path: preparePath(params.metadataPath) });
+        }
+        const { readCredentials, writeCredentials } = this.getStorageCredentials(storage, remotePath);
+        const info = await fs.stat(params.localPath);
+        let { localPath } = params;
+        let sourcePath;
+        if (info.isFile()) {
+            sourcePath = basename(localPath);
+            localPath = dirname(localPath);
+        }
+        try {
+            this.logger.info('Starting upload');
+            const uploadResult = await upload(localPath, {
+                credentials: writeCredentials,
+                filepath: '',
+                storageType: storage.storageType,
+                type: ResourceType.StorageProvider,
+            }, {
+                encryption: params.withEncryption,
+                progressCallback: progressCb,
+                retry: {
+                    initialDelayMs: 0,
+                    maxRetries: 2,
+                },
+                sourcePath,
+                sync: params.sync,
+                threads: params.maximumConcurrent,
+            });
+            uploadResult.resource.storageType = storage.storageType;
+            uploadResult.resource.credentials = readCredentials;
+            const result = {
+                ...metadata,
+                ...uploadResult,
+            };
+            await fs.writeFile(resourceFilePath, JSON.stringify(result, null, 2));
+            this.logger.info(`Resource file was created in ${resourceFilePath}`);
+        }
+        catch (error) {
+            this.logger.error({ err: error }, 'Something went wrong with upload');
+            throw error;
+        }
+    }
+    getStorageCredentials(storage, remotePath) {
+        if (storage.storageType === StorageType.StorJ) {
+            const { readAccessToken, writeAccessToken } = storage.storjCredentials || {};
+            if (!writeAccessToken || !readAccessToken) {
+                throw new StorageError('StorJ credentials are missing or incomplete');
+            }
+            return {
+                readCredentials: {
+                    bucket: storage.bucket,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    token: readAccessToken,
+                }, writeCredentials: {
+                    bucket: storage.bucket,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    token: writeAccessToken,
+                },
+            };
+        }
+        if (storage.storageType === StorageType.S3) {
+            const { readAccessKeyId, readSecretAccessKey, writeAccessKeyId, writeSecretAccessKey } = storage.s3Credentials || {};
+            if (!writeAccessKeyId || !writeSecretAccessKey || !readAccessKeyId || !readSecretAccessKey) {
+                throw new StorageError('S3 credentials are missing or incomplete');
+            }
+            return {
+                readCredentials: {
+                    accessKeyId: readAccessKeyId,
+                    bucket: storage.bucket,
+                    endpoint: S3_ENDPOINT,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    secretKey: readSecretAccessKey,
+                }, writeCredentials: {
+                    accessKeyId: writeAccessKeyId,
+                    bucket: storage.bucket,
+                    endpoint: S3_ENDPOINT,
+                    prefix: joinPaths(storage.prefix, remotePath),
+                    secretKey: writeSecretAccessKey,
+                },
+            };
+        }
+        throw new StorageError(`Unknown storage type: ${storage.storageType}`);
+    }
+}
+__decorate([
+    Retryable({ maxAttempts: 3, value: [StoragesUndefinedError, StorageCreateError, ProviderClientError] })
+], StorageService.prototype, "getCentralizedStorage", null);

package/dist/utils/helper.d.ts

@@ -1 +1,7 @@
 export declare const getConfigName: (name: string) => string;
+export declare const preparePath: (rawPath: string) => string;
+export declare const joinPaths: (...args: string[]) => string;
+export type ReadJsonFileParams = {
+    path: string;
+};
+export declare const readJsonFile: <T>(params: ReadJsonFileParams) => Promise<T>;

package/dist/utils/helper.js

@@ -1 +1,24 @@
+import { existsSync } from 'node:fs';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
 export const getConfigName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-') + '.config.json';
+export const preparePath = (rawPath) => {
+    if (path.isAbsolute(rawPath))
+        return rawPath;
+    return path.join(process.cwd(), rawPath);
+};
+export const joinPaths = (...args) => path.join(...args).replaceAll('\\', '/');
+export const readJsonFile = async (params) => {
+    if (!existsSync(params.path)) {
+        throw new Error(`File could not be found in ${params.path}`);
+    }
+    const jsonString = await fs.readFile(params.path, 'utf8');
+    let parsedValue;
+    try {
+        parsedValue = JSON.parse(jsonString);
+    }
+    catch {
+        throw new Error(`Invalid JSON format of file ${params.path}`);
+    }
+    return parsedValue;
+};

package/dist/utils/progress.d.ts

@@ -0,0 +1,8 @@
+export declare const createProgressPrinter: ({ action, done, start, }: {
+    action: string;
+    done?: string;
+    start: string;
+}) => {
+    advance(key: string, num: number, message: string): void;
+    finish: () => void;
+};

package/dist/utils/progress.js

@@ -0,0 +1,35 @@
+import * as p from '@clack/prompts';
+export const createProgressPrinter = ({ action, done = 'completed', start, }) => {
+    const progressBars = {};
+    let lastKey = '';
+    let lastProgress = 0;
+    const getProgress = (key) => {
+        if (key in progressBars) {
+            lastKey = key;
+            return progressBars[key];
+        }
+        if (lastKey in progressBars) {
+            const progressBar = progressBars[lastKey];
+            lastProgress = 0;
+            progressBar.stop(`${action} ${lastKey} ${done}`);
+        }
+        const progressBar = p.progress({ size: 100, style: 'block' });
+        progressBar.start(`${start} ${key}`);
+        progressBars[key] = progressBar;
+        return progressBar;
+    };
+    const finish = () => {
+        if (lastKey && progressBars[lastKey]) {
+            lastProgress = 0;
+            progressBars[lastKey].stop(`${action} ${lastKey} ${done}`);
+        }
+    };
+    return {
+        advance(key, num, message) {
+            const progress = getProgress(key);
+            progress.advance(num - lastProgress, message);
+            lastProgress = num;
+        },
+        finish,
+    };
+};