@super-protocol/sp-cli 0.0.2-beta.2 → 0.0.2-beta.5

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

@@ -1,8 +1,9 @@
+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 StoragesEmptyError extends StorageError {
+export declare class StoragesUndefinedError extends StorageError {
 }
 export declare class StorageCreateError extends StorageError {
 }
@@ -10,12 +11,40 @@ 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>;
-    getCentralizedStorage(): Promise<{
+    download(params: IDownloadParams, progressCb: ProgressCb): Promise<void>;
+    getCentralizedStorage(): Promise<StorageResponseDto>;
+    getCurrentStorage(): Promise<StorageResponseDto>;
+    hasStorage(): Promise<boolean>;
+    initCentralizedStorage(): Promise<{
         bucket: string;
         createdAt: string;
         id: string;
@@ -26,22 +55,17 @@ export declare class StorageService {
         storjCredentials?: import("@super-protocol/provider-client").components["schemas"]["StorJCredentialsResponseDto"];
         updatedAt: string;
         userId: string;
-    } | undefined>;
-    getCurrentStorage(): Promise<StorageResponseDto>;
-    hasStorage(): Promise<boolean>;
-    initStorage(): Promise<{
-        bucket: string;
+    }>;
+    requestStorages(): Promise<StorageResponseDto[]>;
+    saveStorage(selectedStorage: string): Promise<{
+        activeStorageId: string;
         createdAt: string;
+        decentralizedStorageId?: 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<void>;
     updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
+    upload(params: IUploadParams, progressCb: ProgressCb): Promise<void>;
 }
+export {};

package/dist/services/storage.service.js

@@ -1,7 +1,23 @@
+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 { 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, join } from 'node:path';
+import { Value } from 'typebox/value';
+import { Retryable } from 'typescript-retry-decorator';
+import { storageResourceSchema } from '../config/resource.schema.js';
+import { S3_ENDPOINT } from '../constants.js';
 import { ProviderClientError } from '../errors.js';
+import { preparePath, readJsonFile } from '../utils/helper.js';
 export class StorageError extends Error {
 }
-export class StoragesEmptyError extends StorageError {
+export class StoragesUndefinedError extends StorageError {
 }
 export class StorageCreateError extends StorageError {
 }
@@ -9,6 +25,7 @@ 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;
@@ -39,9 +56,43 @@ export class StorageService {
             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) {
+            localPath = join(localPath, resource.filepath);
+        }
+        await download(resource, localPath, {
+            encryption: resourceFile.encryption,
+            progressCallback: progressCb,
+            threads: params.maximumConcurrent,
+        });
+    }
     async getCentralizedStorage() {
-        const storages = await this.requestStorages();
-        return storages.find(storage => storage.isCentralized);
+        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 {
@@ -67,11 +118,6 @@ export class StorageService {
         try {
             const { data, error } = await this.providerClient.GET('/api/user-settings');
             if (error && error.statusCode === 404) {
-                const storage = await this.getCentralizedStorage();
-                if (storage) {
-                    await this.saveStorage(storage.id);
-                    return true;
-                }
                 return false;
             }
             if (error) {
@@ -89,7 +135,7 @@ export class StorageService {
             throw error_;
         }
     }
-    async initStorage() {
+    async initCentralizedStorage() {
         this.logger.info('Requesting storage initialization');
         try {
             const result = await this.providerClient.POST('/api/storages/centralized');
@@ -120,9 +166,9 @@ export class StorageService {
                 this.logger.error({ err: result.error }, 'Failed to fetch storages');
                 throw new StorageError(result.error.message);
             }
-            if (!data || !data?.length) {
-                this.logger.warn('Storages list is empty');
-                throw new StoragesEmptyError('Storages is empty please create or import first one');
+            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;
@@ -142,9 +188,10 @@ export class StorageService {
                 },
             });
             if (error) {
-                throw new StorageError(`User settings request error ${error?.message}`);
+                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');
@@ -161,7 +208,7 @@ export class StorageService {
             });
             if (error) {
                 this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
-                throw new StorageUpdateError(error?.message);
+                throw new StorageUpdateError(error.message);
             }
             if (!data) {
                 this.logger.error({ storageId: id }, 'Provider returned empty storage update response');
@@ -176,4 +223,86 @@ export class StorageService {
             throw error_;
         }
     }
+    async upload(params, progressCb) {
+        const storage = await this.getCurrentStorage();
+        const remotePath = `${params.remotePath || generateExternalId()}`;
+        const resourceFilePath = preparePath(params.outputPath || '');
+        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 writeCredentials = storage.storageType === StorageType.StorJ
+            ? {
+                bucket: storage.bucket,
+                prefix: join(storage.prefix, remotePath),
+                token: storage.storjCredentials.writeAccessToken,
+            }
+            : {
+                accessKeyId: storage.s3Credentials.writeAccessKeyId,
+                bucket: storage.bucket,
+                endpoint: S3_ENDPOINT,
+                prefix: join(storage.prefix, remotePath),
+                secretKey: storage.s3Credentials.writeSecretAccessKey,
+            };
+        const readCredentials = storage.storageType === StorageType.StorJ
+            ? {
+                bucket: storage.bucket,
+                prefix: join(storage.prefix, remotePath),
+                token: storage.storjCredentials.readAccessToken,
+            }
+            : {
+                accessKeyId: storage.s3Credentials.readAccessKeyId,
+                bucket: storage.bucket,
+                endpoint: S3_ENDPOINT,
+                prefix: join(storage.prefix, remotePath),
+                secretKey: storage.s3Credentials.readSecretAccessKey,
+            };
+        const info = await fs.stat(params.localPath);
+        let { localPath } = params;
+        let sourcePath;
+        if (info.isFile()) {
+            sourcePath = basename(localPath);
+            localPath = dirname(localPath);
+        }
+        try {
+            const uploadResult = await upload(localPath, {
+                credentials: writeCredentials,
+                filepath: '',
+                storageType: storage.storageType,
+                type: ResourceType.StorageProvider,
+            }, {
+                encryption: params.withEncryption,
+                progressCallback: progressCb,
+                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 }, 'Somethong went wrong with upload');
+            console.log(error);
+            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            throw error_;
+        }
+    }
 }
+__decorate([
+    Retryable({ maxAttempts: 3, value: [StoragesUndefinedError, StorageCreateError, ProviderClientError] })
+], StorageService.prototype, "getCentralizedStorage", null);

package/dist/utils/helper.d.ts

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

package/dist/utils/helper.js

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

package/oclif.manifest.json

@@ -74,7 +74,9 @@
       ]
     },
     "auth:login": {
-      "aliases": [],
+      "aliases": [
+        "login"
+      ],
       "args": {},
       "description": "Authorization",
       "examples": [
@@ -473,6 +475,161 @@
         "use.js"
       ]
     },
+    "files:download": {
+      "aliases": [],
+      "args": {
+        "resourceFile": {
+          "description": "Path to a resource file",
+          "name": "resourceFile",
+          "required": true
+        },
+        "localDirectory": {
+          "description": "Path to save downloaded file",
+          "name": "localDirectory",
+          "required": true
+        }
+      },
+      "description": "describe the command here",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> ./resource.json ./pathToDownload "
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "config": {
+          "helpGroup": "GLOBAL",
+          "name": "config",
+          "required": false,
+          "summary": "Specify config file.",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "maximum-concurrent": {
+          "description": "Maximum concurrent pieces to upload at once per transfer",
+          "name": "maximum-concurrent",
+          "default": 1,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "files:download",
+      "pluginAlias": "@super-protocol/sp-cli",
+      "pluginName": "@super-protocol/sp-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "help": "Download and decrypt a file from the remote storage to <localPath> using resource file <resourcePath>",
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "files",
+        "download.js"
+      ]
+    },
+    "files:upload": {
+      "aliases": [],
+      "args": {
+        "path": {
+          "description": "file or directory to upload",
+          "name": "path",
+          "required": true
+        }
+      },
+      "description": "describe the command here",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> ./file.txt"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "config": {
+          "helpGroup": "GLOBAL",
+          "name": "config",
+          "required": false,
+          "summary": "Specify config file.",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "filename": {
+          "description": "The name of the resulting file/directory in the storage",
+          "name": "filename",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "maximum-concurrent": {
+          "description": "Maximum concurrent pieces to upload at once per transfer",
+          "name": "maximum-concurrent",
+          "default": 1,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "metadata": {
+          "description": "Path to a metadata file for adding fields to the resource file",
+          "name": "metadata",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "output": {
+          "description": "Path to save resource file that is used to access the uploaded file",
+          "name": "output",
+          "required": false,
+          "default": "resource.json",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "skip-encryption": {
+          "description": "Skip file encryption before upload",
+          "name": "skip-encryption",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "sync": {
+          "description": "Sync mode: delete files in target that don't exist in source",
+          "name": "sync",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "files:upload",
+      "pluginAlias": "@super-protocol/sp-cli",
+      "pluginName": "@super-protocol/sp-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "files",
+        "upload.js"
+      ]
+    },
     "storage:base": {
       "aliases": [],
       "args": {},
@@ -679,5 +836,5 @@
       ]
     }
   },
-  "version": "0.0.2-beta.2"
+  "version": "0.0.2-beta.5"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@super-protocol/sp-cli",
   "description": "SuperProtocol Command line interface",
-  "version": "0.0.2-beta.2",
+  "version": "0.0.2-beta.5",
   "author": "SuperProtocol",
   "publishConfig": {
     "access": "public",
@@ -13,19 +13,21 @@
   },
   "bugs": "https://github.com/Super-Protocol/sp-cli/issues",
   "dependencies": {
-    "@clack/prompts": "^0.11.0",
+    "@clack/prompts": "^1.0.0-alpha.6",
     "@oclif/core": "^4.7.2",
+    "@oclif/plugin-autocomplete": "^3.2.39",
     "@oclif/plugin-help": "^6.2.33",
-    "@oclif/plugin-plugins": "^5.4.50",
     "@oclif/plugin-warn-if-update-available": "^3.1.50",
     "@sinclair/typebox": "^0.33.22",
-    "@super-protocol/provider-client": "^0.1.7",
-    "@super-protocol/sp-files-addon": "^0.12.5",
+    "@super-protocol/dto-js": "^1.3.0",
+    "@super-protocol/provider-client": "^0.1.8",
+    "@super-protocol/sp-files-addon": "^0.12.7",
     "cookie": "^1.0.2",
     "jsonwebtoken": "^9.0.2",
     "pino": "^9.14.0",
     "pino-pretty": "^13.1.2",
     "tough-cookie": "^6.0.0",
+    "typebox": "^1.0.55",
     "typescript-retry-decorator": "^2.4.2",
     "viem": "^2.38.3"
   },
@@ -66,8 +68,7 @@
   "oclif": {
     "bin": "sp",
     "binAliases": [
-      "spcli",
-      "sp-cli"
+      "spcli"
     ],
     "dirname": "sp",
     "commands": {
@@ -81,7 +82,6 @@
     },
     "plugins": [
       "@oclif/plugin-help",
-      "@oclif/plugin-plugins",
       "@oclif/plugin-warn-if-update-available"
     ],
     "warn-if-update-available": {