@super-protocol/sp-cli 0.0.2 → 0.0.4-beta.0

package/dist/commands/files/upload.js

@@ -0,0 +1,79 @@
+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 = 'Upload file or directory to remote storage';
+    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 storageService = new StorageService(providerClient, this.logger);
+        const progress = createProgressPrinter({
+            action: 'Upload',
+            start: 'Uploading: ',
+        });
+        try {
+            await storageService.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}]`);
+            });
+        }
+        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}`);
+        }
+        finally {
+            progress.finish();
+        }
+        this.log('Upload successfully completed');
+    }
+}

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

@@ -0,0 +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;
+}

package/dist/commands/storage/base.js

@@ -0,0 +1,125 @@
+import { password, select, text } from '@clack/prompts';
+import { StorageType } from '@super-protocol/provider-client';
+import { BaseCommand } from '../../commands/base.js';
+import { S3_REGION } from '../../constants.js';
+import { StorageService } from '../../services/storage.service.js';
+export class BaseStorageCommand extends BaseCommand {
+    currentDir = process.cwd();
+    storageService;
+    async init() {
+        await super.init();
+        await this.container.initConfigManager().initProviderClient().build();
+        const { providerClient } = this.container;
+        this.storageService = new StorageService(providerClient, this.logger);
+    }
+    async promptS3Credentials() {
+        const region = S3_REGION;
+        const readAccessKeyId = this.ensurePromptValue(await text({
+            message: 'Read access key ID',
+            validate(value) {
+                return value ? undefined : 'Read access key ID is required';
+            },
+        })).trim();
+        const readSecretAccessKey = this.ensurePromptValue(await password({
+            message: 'Read secret access key',
+            validate(value) {
+                return value ? undefined : 'Read secret access key is required';
+            },
+        })).trim();
+        const writeAccessKeyId = this.ensurePromptValue(await text({
+            message: 'Write access key ID',
+            validate(value) {
+                return value ? undefined : 'Write access key ID is required';
+            },
+        })).trim();
+        const writeSecretAccessKey = this.ensurePromptValue(await password({
+            message: 'Write secret access key',
+            validate(value) {
+                return value ? undefined : 'Write secret access key is required';
+            },
+        })).trim();
+        return {
+            readAccessKeyId,
+            readSecretAccessKey,
+            region,
+            writeAccessKeyId,
+            writeSecretAccessKey,
+        };
+    }
+    async promptStoragePayload() {
+        const storageType = this.ensurePromptValue(await select({
+            message: 'Select storage type',
+            options: [
+                { label: 'S3', value: StorageType.S3 },
+                { label: 'StorJ', value: StorageType.StorJ },
+            ],
+        }));
+        const bucket = this.ensurePromptValue(await text({
+            message: 'Bucket name',
+            validate(value) {
+                return value ? undefined : 'Bucket is required';
+            },
+        })).trim();
+        const prefix = this.ensurePromptValue(await text({
+            defaultValue: '/',
+            initialValue: '/',
+            message: 'Prefix',
+            validate(value) {
+                return value ? undefined : 'Prefix is required';
+            },
+        })).trim();
+        const storage = {
+            bucket,
+            prefix,
+            storageType,
+        };
+        if (storageType === StorageType.S3) {
+            storage.s3Credentials = await this.promptS3Credentials();
+        }
+        if (storageType === StorageType.StorJ) {
+            storage.storjCredentials = await this.promptStorJCredentials();
+        }
+        return storage;
+    }
+    async promptStorJCredentials() {
+        const readAccessToken = this.ensurePromptValue(await password({
+            message: 'Read access token',
+            validate(value) {
+                return value ? undefined : 'Read access token is required';
+            },
+        })).trim();
+        const writeAccessToken = this.ensurePromptValue(await password({
+            message: 'Write access token',
+            validate(value) {
+                return value ? undefined : 'Write access token is required';
+            },
+        })).trim();
+        return {
+            readAccessToken,
+            writeAccessToken,
+        };
+    }
+    validateStoragePayload(payload) {
+        if (!payload || typeof payload !== 'object') {
+            this.error('Storage definition must be an object');
+        }
+        if (!payload.bucket) {
+            this.error('Storage definition missing "bucket"');
+        }
+        if (!payload.prefix) {
+            this.error('Storage definition missing "prefix"');
+        }
+        if (!payload.storageType) {
+            this.error('Storage definition missing "storageType"');
+        }
+        if (!Object.values(StorageType).includes(payload.storageType)) {
+            this.error(`Unsupported storage type: ${payload.storageType}`);
+        }
+        if (payload.storageType === StorageType.S3 && !payload.s3Credentials) {
+            this.error('S3 storage requires "s3Credentials"');
+        }
+        if (payload.storageType === StorageType.StorJ && !payload.storjCredentials) {
+            this.error('StorJ storage requires "storjCredentials"');
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseStorageCommand } from './base.js';
+export default class StorageCreate extends BaseStorageCommand<typeof StorageCreate> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        fromFile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        notDefault: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private loadStorageFromFile;
+}

package/dist/commands/storage/create.js

@@ -0,0 +1,53 @@
+import { Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { BaseStorageCommand } from './base.js';
+export default class StorageCreate extends BaseStorageCommand {
+    static description = 'Create a new storage entry from file or interactive prompts.';
+    static examples = [
+        '<%= config.bin %> storage create',
+        '<%= config.bin %> storage create --fromFile ./storage.json',
+        '<%= config.bin %> storage create --not-default',
+    ];
+    static flags = {
+        fromFile: Flags.string({
+            aliases: ['fromFile'],
+            char: 'f',
+            description: 'Path to a JSON file that contains AddStorageDto payload.',
+        }),
+        notDefault: Flags.boolean({
+            description: 'Skip setting the created storage as default.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StorageCreate);
+        const payload = flags.fromFile
+            ? await this.loadStorageFromFile(flags.fromFile)
+            : await this.promptStoragePayload();
+        try {
+            const storage = await this.storageService.createStorage(payload);
+            this.log(`Storage created: ${storage.id}`);
+            if (!flags.notDefault) {
+                await this.storageService.saveStorage(storage.id);
+                this.log('Storage set as default');
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async loadStorageFromFile(filePath) {
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.currentDir, filePath);
+        try {
+            const fileContent = await fs.readFile(absolutePath, 'utf8');
+            const parsed = JSON.parse(fileContent);
+            this.validateStoragePayload(parsed);
+            return parsed;
+        }
+        catch (error) {
+            this.error(`Failed to load storage definition: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { BaseStorageCommand } from './base.js';
+export default class StorageSelect extends BaseStorageCommand<typeof StorageSelect> {
+    static description: string;
+    static examples: string[];
+    run(): Promise<{
+        label: string;
+        selectedStorageId: string;
+    }>;
+}

package/dist/commands/storage/select.js

@@ -0,0 +1,40 @@
+import { select } from '@clack/prompts';
+import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { BaseStorageCommand } from './base.js';
+export default class StorageSelect extends BaseStorageCommand {
+    static description = 'Select a storage that will be used by subsequent commands.';
+    static examples = [
+        '<%= config.bin %> storage select',
+    ];
+    async run() {
+        try {
+            const storages = await this.storageService.requestStorages();
+            const storageId = this.ensurePromptValue(await select({
+                message: 'Select storage',
+                options: storages.map(storage => ({
+                    label: this.storageService.getLabel(storage),
+                    value: storage.id,
+                })),
+            }));
+            if (!storageId) {
+                this.error('Storage ID is required');
+            }
+            const storage = storages.find(storage => storage.id === storageId);
+            if (!storage) {
+                this.error(`Storage with ID: ${storageId} not found `);
+            }
+            const label = this.storageService.getLabel(storage);
+            await this.storageService.saveStorage(storageId);
+            this.log(`Selected storage: ${label}`);
+            return { label, selectedStorageId: storageId };
+        }
+        catch (error) {
+            if (error instanceof StoragesUndefinedError) {
+                this.error('No storages available. Run "sp storage create" first.');
+            }
+            else {
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { BaseStorageCommand } from './base.js';
+export default class StorageShow extends BaseStorageCommand<typeof StorageShow> {
+    static description: string;
+    static examples: string[];
+    run(): 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;
+    }>;
+}

package/dist/commands/storage/show.js

@@ -0,0 +1,36 @@
+import { StorageType } from '@super-protocol/provider-client';
+import { BaseStorageCommand } from './base.js';
+const stripString = (str, chars) => {
+    if (str.length <= 2 * chars) {
+        return '*'.repeat(str.length);
+    }
+    return `${str.slice(0, chars)}...${str.slice(-1 * chars)}`;
+};
+export default class StorageShow extends BaseStorageCommand {
+    static description = 'Show current selected storage';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        const storage = await this.storageService.getCurrentStorage();
+        this.log(`Current storage: ${storage.isCentralized ? 'Super Cloud' : 'Custom storage'}`);
+        this.log(`- ID: ${storage.id}`);
+        this.log(`- Storage type: ${storage.storageType}`);
+        this.log(`- Bucket: ${storage.bucket}`);
+        this.log(`- Prefix: ${storage.prefix}`);
+        this.log(' -- Credentials --');
+        if (storage.storageType === StorageType.S3) {
+            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '' } = storage.s3Credentials || {};
+            this.log(`    readAccessKeyId: ${readAccessKeyId}`);
+            this.log(`    readSecretAccessKey: ${stripString(readSecretAccessKey, 5)}`);
+            this.log(`    writeAccessKeyId: ${writeAccessKeyId}`);
+            this.log(`    writeSecretAccessKey: ${stripString(writeSecretAccessKey, 5)}`);
+        }
+        else {
+            const { readAccessToken = '', writeAccessToken = '' } = storage.storjCredentials || {};
+            this.log(`    readAccessToken: ${stripString(readAccessToken, 5)}`);
+            this.log(`    writeAccessToken: ${stripString(writeAccessToken, 5)}`);
+        }
+        return storage;
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BaseStorageCommand } from './base.js';
+export default class StorageUpdate extends BaseStorageCommand<typeof StorageUpdate> {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        fromFile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private ensureNonEmptyString;
+    private ensureUpdatePayload;
+    private loadStorageFromFile;
+    private promptStorageUpdate;
+}

package/dist/commands/storage/update.js

@@ -0,0 +1,187 @@
+import { confirm, select, text, } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { StorageType } from '@super-protocol/provider-client';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { BaseStorageCommand } from './base.js';
+export default class StorageUpdate extends BaseStorageCommand {
+    static description = 'Update the configuration of an existing storage.';
+    static examples = [
+        '<%= config.bin %> storage update --id=2de3e3a4-0000-1111-2222-333344445555 --fromFile ./storage-update.json',
+        '<%= config.bin %> storage update --id=2de3e3a4-0000-1111-2222-333344445555',
+    ];
+    static flags = {
+        fromFile: Flags.string({
+            char: 'f',
+            description: 'Path to a JSON file that contains UpdateStorageDto payload.',
+        }),
+        id: Flags.string({
+            char: 'i',
+            description: 'Storage ID to update',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StorageUpdate);
+        try {
+            const shouldRequestStorages = !flags.fromFile || !flags.id;
+            const storages = shouldRequestStorages ? await this.storageService.requestStorages() : undefined;
+            let storageId = flags.id;
+            if (!storageId) {
+                const options = (storages || []).filter(cp => !cp.isCentralized).map(storage => ({
+                    label: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
+                    value: storage.id,
+                }));
+                if (!options || options.length === 0) {
+                    throw new StoragesUndefinedError('No storages available to update');
+                }
+                storageId = this.ensurePromptValue(await select({
+                    message: 'Select storage to update',
+                    options,
+                }));
+            }
+            if (!storageId) {
+                this.error('Storage ID is required');
+            }
+            const storageToUpdate = storages?.find(storage => storage.id === storageId);
+            if (flags.id && storages && !storageToUpdate) {
+                this.error(`Storage with ID ${storageId} not found`);
+            }
+            const updatePayload = flags.fromFile
+                ? await this.loadStorageFromFile(flags.fromFile)
+                : await this.promptStorageUpdate(storageToUpdate);
+            await this.storageService.updateStorage(storageId, updatePayload);
+            this.log(`Storage updated: ${storageId}`);
+        }
+        catch (error) {
+            if (error instanceof StoragesUndefinedError) {
+                this.error('No storages available. Run "sp storage create" first.');
+            }
+            else {
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    ensureNonEmptyString(value, fieldName) {
+        if (typeof value !== 'string' || !value.trim()) {
+            this.error(`${fieldName} must be a non-empty string`);
+        }
+        return value.trim();
+    }
+    ensureUpdatePayload(payload) {
+        if (!payload || typeof payload !== 'object') {
+            this.error('Storage update definition must be an object');
+        }
+        const updateFields = ['bucket', 'prefix', 'storageType', 's3Credentials', 'storjCredentials'];
+        const hasUpdates = updateFields.some(key => payload[key] !== undefined);
+        if (!hasUpdates) {
+            this.error('Update payload must include at least one property');
+        }
+        if (payload.storageType && !Object.values(StorageType).includes(payload.storageType)) {
+            this.error(`Unsupported storage type: ${payload.storageType}`);
+        }
+        if (payload.s3Credentials) {
+            const { readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId, writeSecretAccessKey, } = payload.s3Credentials;
+            if (!readAccessKeyId || !readSecretAccessKey || !region || !writeAccessKeyId || !writeSecretAccessKey) {
+                this.error('S3 credentials must include readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId and writeSecretAccessKey');
+            }
+        }
+        if (payload.storjCredentials) {
+            const { readAccessToken, writeAccessToken } = payload.storjCredentials;
+            if (!readAccessToken || !writeAccessToken) {
+                this.error('StorJ credentials must include readAccessToken and writeAccessToken');
+            }
+        }
+        const sanitized = {};
+        if (payload.bucket !== undefined) {
+            sanitized.bucket = this.ensureNonEmptyString(payload.bucket, 'Bucket');
+        }
+        if (payload.prefix !== undefined) {
+            sanitized.prefix = this.ensureNonEmptyString(payload.prefix, 'Prefix');
+        }
+        if (payload.storageType) {
+            sanitized.storageType = payload.storageType;
+        }
+        if (payload.s3Credentials) {
+            sanitized.s3Credentials = {
+                readAccessKeyId: this.ensureNonEmptyString(payload.s3Credentials.readAccessKeyId, 'S3 credential "readAccessKeyId"'),
+                readSecretAccessKey: this.ensureNonEmptyString(payload.s3Credentials.readSecretAccessKey, 'S3 credential "readSecretAccessKey"'),
+                region: this.ensureNonEmptyString(payload.s3Credentials.region, 'S3 credential "region"'),
+                writeAccessKeyId: this.ensureNonEmptyString(payload.s3Credentials.writeAccessKeyId, 'S3 credential "writeAccessKeyId"'),
+                writeSecretAccessKey: this.ensureNonEmptyString(payload.s3Credentials.writeSecretAccessKey, 'S3 credential "writeSecretAccessKey"'),
+            };
+        }
+        if (payload.storjCredentials) {
+            sanitized.storjCredentials = {
+                readAccessToken: this.ensureNonEmptyString(payload.storjCredentials.readAccessToken, 'StorJ credential "readAccessToken"'),
+                writeAccessToken: this.ensureNonEmptyString(payload.storjCredentials.writeAccessToken, 'StorJ credential "writeAccessToken"'),
+            };
+        }
+        return sanitized;
+    }
+    async loadStorageFromFile(filePath) {
+        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(this.currentDir, filePath);
+        try {
+            const fileContent = await fs.readFile(absolutePath, 'utf8');
+            const parsed = JSON.parse(fileContent);
+            return this.ensureUpdatePayload(parsed);
+        }
+        catch (error) {
+            this.error(`Failed to load storage update definition: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async promptStorageUpdate(existingStorage) {
+        const payload = {};
+        const bucket = this.ensurePromptValue(await text({
+            defaultValue: existingStorage?.bucket ?? '',
+            message: 'Bucket name (leave empty to keep current)',
+        })).trim();
+        if (bucket) {
+            payload.bucket = bucket;
+        }
+        const prefix = this.ensurePromptValue(await text({
+            defaultValue: existingStorage?.prefix ?? '',
+            message: 'Prefix (leave empty to keep current)',
+        })).trim();
+        if (prefix) {
+            payload.prefix = prefix;
+        }
+        let newStorageType;
+        const shouldChangeType = this.ensurePromptValue(await confirm({
+            initialValue: false,
+            message: existingStorage
+                ? `Change storage type? (current: ${existingStorage.storageType})`
+                : 'Change storage type?',
+        }));
+        if (shouldChangeType) {
+            newStorageType = this.ensurePromptValue(await select({
+                message: 'Select new storage type',
+                options: [
+                    { label: 'Amazon S3', value: StorageType.S3 },
+                    { label: 'StorJ', value: StorageType.StorJ },
+                ],
+            }));
+            payload.storageType = newStorageType;
+        }
+        const effectiveType = newStorageType ?? existingStorage?.storageType;
+        const credentialsRequired = Boolean(newStorageType);
+        if (effectiveType) {
+            const updateCredentials = credentialsRequired || this.ensurePromptValue(await confirm({
+                initialValue: false,
+                message: `Update ${effectiveType} credentials?`,
+            }));
+            if (updateCredentials) {
+                if (effectiveType === StorageType.S3) {
+                    payload.s3Credentials = await this.promptS3Credentials();
+                }
+                else {
+                    payload.storjCredentials = await this.promptStorJCredentials();
+                }
+            }
+        }
+        if (Object.keys(payload).length === 0) {
+            this.error('No changes provided');
+        }
+        return this.ensureUpdatePayload(payload);
+    }
+}

package/dist/commands/workflows/extend-lease.d.ts

@@ -0,0 +1,17 @@
+import { SelectOptions } from '@clack/prompts';
+import { BaseCommand } from '../base.js';
+export default class WorkflowsExtendLease extends BaseCommand<typeof WorkflowsExtendLease> {
+    static args: {
+        orderId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        minutes: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sppi: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected selectPrompt<Value>(options: SelectOptions<Value>): Promise<Value>;
+}