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

package/dist/commands/config/add.js

@@ -48,7 +48,6 @@ export default class ConfigAdd extends BaseConfigCommand {
                     if (!existsSync(testPath)) {
                         return 'File does not exist';
                     }
-                    return true;
                 },
             });
         }
@@ -66,15 +65,20 @@ export default class ConfigAdd extends BaseConfigCommand {
             this.log(`Successfully imported configuration: ${displayName}`);
             this.log(`Configuration file: ${importedFileName}`);
             const shouldSwitch = this.flags.yes || await this.selectPrompt({
-                choices: [
-                    { name: 'Yes', value: true },
-                    { name: 'No', value: false },
-                ],
                 message: 'Switch to this configuration now?',
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
             });
             if (shouldSwitch) {
                 await this.configFileManager.setCurrentConfig(importedFileName);
                 this.log(`Switched to configuration: ${displayName}`);
+                await this.container
+                    .initConfigFileManager(true)
+                    .initConfigManager(true)
+                    .initAccountManager(true)
+                    .build();
             }
         }
         catch (error) {

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

@@ -1,14 +1,15 @@
 import type { Command } from '@oclif/core';
-import { input, select } from '@inquirer/prompts';
+import { select, text } from '@clack/prompts';
 import type { ConfigFileManager } from '../../managers/config-file-manager.js';
 import { BaseCommand } from '../base.js';
-type InputOptions = Parameters<typeof input>[0];
+type TextOptions = Parameters<typeof text>[0];
 type SelectOptions<T> = Parameters<typeof select<T>>[0];
 export declare abstract class BaseConfigCommand<T extends typeof Command> extends BaseCommand<T> {
+    static baseFlags: {};
     protected configFileManager: ConfigFileManager;
     protected displayCurrentConfig(): void;
     init(): Promise<void>;
-    protected inputPrompt(options: InputOptions): Promise<string>;
+    protected inputPrompt(options: TextOptions): Promise<string>;
     protected selectPrompt<Value>(options: SelectOptions<Value>): Promise<Value>;
 }
 export {};

package/dist/commands/config/base.js

@@ -1,6 +1,8 @@
-import { input, select } from '@inquirer/prompts';
+import { select, text } from '@clack/prompts';
+import { PROVIDER_URL } from '../../constants.js';
 import { BaseCommand } from '../base.js';
 export class BaseConfigCommand extends BaseCommand {
+    static baseFlags = {};
     configFileManager;
     displayCurrentConfig() {
         const current = this.configFileManager.getCurrentConfigFile();
@@ -20,25 +22,19 @@ export class BaseConfigCommand extends BaseCommand {
                     this.log(`  Provider URL: ${configData.providerUrl}`);
                 }
                 else {
-                    this.log('  Provider URL: (using default)');
+                    this.log(`  Provider URL: ${PROVIDER_URL} (using default)`);
                 }
                 if (configData.auth?.accessKey) {
-                    this.log('  Authorization: ✓ Configured');
+                    this.log('  Authorization: [OK] Configured');
                 }
                 else {
-                    this.log('  Authorization: ✗ Not configured');
+                    this.log('  Authorization: [--] Not configured');
                 }
                 if (configData.account?.address) {
-                    this.log(`  Account: ✓ ${configData.account.address}`);
+                    this.log(`  Account: [OK] ${configData.account.address}`);
                 }
                 else {
-                    this.log('  Account: ✗ Not configured');
-                }
-                if (configData.cookies) {
-                    this.log('  Cookies: ✓ Stored');
-                }
-                else {
-                    this.log('  Cookies: ✗ None');
+                    this.log('  Account: [--] Not configured');
                 }
             }
         }
@@ -54,9 +50,11 @@ export class BaseConfigCommand extends BaseCommand {
         this.configFileManager = this.container.configFileManager;
     }
     async inputPrompt(options) {
-        return input(options);
+        const result = await text(options);
+        return this.ensurePromptValue(result);
     }
     async selectPrompt(options) {
-        return select(options);
+        const result = await select(options);
+        return this.ensurePromptValue(result);
     }
 }

package/dist/commands/config/create.js

@@ -33,11 +33,11 @@ export default class ConfigCreate extends BaseConfigCommand {
                 this.log(`Provider URL: ${url}`);
             }
             const shouldSwitch = yes || await this.selectPrompt({
-                choices: [
-                    { name: 'Yes', value: true },
-                    { name: 'No', value: false },
-                ],
                 message: 'Switch to this configuration now?',
+                options: [
+                    { label: 'Yes', value: true },
+                    { label: 'No', value: false },
+                ],
             });
             if (shouldSwitch) {
                 await this.configFileManager.setCurrentConfig(fileName);

package/dist/commands/config/list.js

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

package/dist/commands/config/use.js

@@ -6,17 +6,19 @@ export default class ConfigUse extends BaseConfigCommand {
     ];
     async run() {
         const configs = this.configFileManager.getConfigsWithNames();
+        const currentConfig = this.configFileManager.getCurrentConfigFile();
         if (configs.length === 0) {
             this.log('No configurations found');
             this.log('Create a new configuration with: sp config create --name "Config Name"');
             return;
         }
         const selected = await this.selectPrompt({
-            choices: configs.map(config => ({
-                name: config.name ?? config.file,
+            initialValue: currentConfig,
+            message: 'Select a configuration:',
+            options: configs.map(config => ({
+                label: config.name ?? config.file,
                 value: config.file,
             })),
-            message: 'Select a configuration:',
         });
         await this.configFileManager.setCurrentConfig(selected);
         const selectedConfig = configs.find(c => c.file === selected);

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

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+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>;
+}

package/dist/commands/storage/base.js

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../commands/base.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);
+    }
+}

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

@@ -0,0 +1,15 @@
+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;
+    private promptS3Credentials;
+    private promptStoragePayload;
+    private promptStorJCredentials;
+    private validateStoragePayload;
+}

package/dist/commands/storage/create.js

@@ -0,0 +1,169 @@
+import { password, 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 { 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)}`);
+        }
+    }
+    async promptS3Credentials() {
+        const region = this.ensurePromptValue(await text({
+            message: 'AWS region',
+            validate(value) {
+                return value ? undefined : 'Region is required';
+            },
+        })).trim();
+        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: 'Amazon 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: '/',
+            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/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[];
+    static flags: {
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/storage/select.js

@@ -0,0 +1,46 @@
+import { select } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { StoragesEmptyError } 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',
+        '<%= config.bin %> storage select --id=2de3e3a4-0000-1111-2222-333344445555',
+    ];
+    static flags = {
+        id: Flags.string({
+            char: 'i',
+            description: 'Storage ID to select',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(StorageSelect);
+        try {
+            let storageId = flags.id;
+            if (!storageId) {
+                const storages = await this.storageService.requestStorages();
+                storageId = this.ensurePromptValue(await select({
+                    message: 'Select storage',
+                    options: storages.map(storage => ({
+                        label: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
+                        value: storage.id,
+                    })),
+                }));
+            }
+            if (!storageId) {
+                this.error('Storage ID is required');
+            }
+            await this.storageService.saveStorage(storageId);
+            this.log(`Selected storage: ${storageId}`);
+        }
+        catch (error) {
+            if (error instanceof StoragesEmptyError) {
+                this.error('No storages available. Run "sp storage create" first.');
+            }
+            else {
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+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 promptS3Credentials;
+    private promptStorageUpdate;
+    private promptStorJCredentials;
+}