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

package/dist/commands/files/upload.js

@@ -0,0 +1,77 @@
+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 = 'describe the command here';
+    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 storageSerivce = new StorageService(providerClient, this.logger);
+        const progress = createProgressPrinter({
+            action: 'Upload',
+            start: 'Uploading: ',
+        });
+        try {
+            await storageSerivce.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}]`);
+            });
+            progress.finish();
+        }
+        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}`);
+        }
+        this.log('Upload successful completed');
+    }
+}

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

@@ -1,8 +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

@@ -1,3 +1,5 @@
+import { password, select, text } from '@clack/prompts';
+import { StorageType } from '@super-protocol/provider-client';
 import { BaseCommand } from '../../commands/base.js';
 import { StorageService } from '../../services/storage.service.js';
 export class BaseStorageCommand extends BaseCommand {
@@ -9,4 +11,113 @@ export class BaseStorageCommand extends BaseCommand {
         const { providerClient } = this.container;
         this.storageService = new StorageService(providerClient, this.logger);
     }
+    async promptS3Credentials() {
+        const region = 'us-east-1';
+        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: '/',
+            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

@@ -8,8 +8,4 @@ export default class StorageCreate extends BaseStorageCommand<typeof StorageCrea
     };
     run(): Promise<void>;
     private loadStorageFromFile;
-    private promptS3Credentials;
-    private promptStoragePayload;
-    private promptStorJCredentials;
-    private validateStoragePayload;
 }

package/dist/commands/storage/create.js

@@ -1,6 +1,4 @@
-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';
@@ -52,118 +50,4 @@ export default class StorageCreate extends BaseStorageCommand {
             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.js

@@ -1,6 +1,6 @@
 import { select } from '@clack/prompts';
 import { Flags } from '@oclif/core';
-import { StoragesEmptyError } from '../../services/storage.service.js';
+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.';
@@ -35,7 +35,7 @@ export default class StorageSelect extends BaseStorageCommand {
             this.log(`Selected storage: ${storageId}`);
         }
         catch (error) {
-            if (error instanceof StoragesEmptyError) {
+            if (error instanceof StoragesUndefinedError) {
                 this.error('No storages available. Run "sp storage create" first.');
             }
             else {

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

@@ -10,7 +10,5 @@ export default class StorageUpdate extends BaseStorageCommand<typeof StorageUpda
     private ensureNonEmptyString;
     private ensureUpdatePayload;
     private loadStorageFromFile;
-    private promptS3Credentials;
     private promptStorageUpdate;
-    private promptStorJCredentials;
 }

package/dist/commands/storage/update.js

@@ -1,9 +1,9 @@
-import { confirm, password, select, text, } from '@clack/prompts';
+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 { StoragesEmptyError } from '../../services/storage.service.js';
+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.';
@@ -33,7 +33,7 @@ export default class StorageUpdate extends BaseStorageCommand {
                     value: storage.id,
                 }));
                 if (!options || options.length === 0) {
-                    throw new StoragesEmptyError('No storages available to update');
+                    throw new StoragesUndefinedError('No storages available to update');
                 }
                 storageId = this.ensurePromptValue(await select({
                     message: 'Select storage to update',
@@ -54,7 +54,7 @@ export default class StorageUpdate extends BaseStorageCommand {
             this.log(`Storage updated: ${storageId}`);
         }
         catch (error) {
-            if (error instanceof StoragesEmptyError) {
+            if (error instanceof StoragesUndefinedError) {
                 this.error('No storages available. Run "sp storage create" first.');
             }
             else {
@@ -130,45 +130,6 @@ export default class StorageUpdate extends BaseStorageCommand {
             this.error(`Failed to load storage update 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 promptStorageUpdate(existingStorage) {
         const payload = {};
         const bucket = this.ensurePromptValue(await text({
@@ -223,22 +184,4 @@ export default class StorageUpdate extends BaseStorageCommand {
         }
         return this.ensureUpdatePayload(payload);
     }
-    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,
-        };
-    }
 }

package/dist/config/config-file.schema.d.ts

@@ -1,6 +1,6 @@
-import { Static } from '@sinclair/typebox';
-export declare const configFileManagerSchema: import("@sinclair/typebox").TObject<{
-    configs: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
-    currentConfig: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+import { Static, Type } from 'typebox';
+export declare const configFileManagerSchema: Type.TObject<{
+    configs: Type.TArray<Type.TString>;
+    currentConfig: Type.TOptional<Type.TString>;
 }>;
 export type ConfigFileManagerData = Static<typeof configFileManagerSchema>;

package/dist/config/config-file.schema.js

@@ -1,4 +1,4 @@
-import { Type } from '@sinclair/typebox';
+import { Type } from 'typebox';
 export const configFileManagerSchema = Type.Object({
     configs: Type.Array(Type.String()),
     currentConfig: Type.Optional(Type.String()),

package/dist/config/config.schema.d.ts

@@ -1,23 +1,23 @@
-import { Static } from '@sinclair/typebox';
-export declare const accountSchema: import("@sinclair/typebox").TObject<{
-    address: import("@sinclair/typebox").TString;
-    privateKey: import("@sinclair/typebox").TString;
+import { Static, Type } from 'typebox';
+export declare const accountSchema: Type.TObject<{
+    address: Type.TString;
+    privateKey: Type.TString;
 }>;
-export declare const authSchema: import("@sinclair/typebox").TObject<{
-    accessKey: import("@sinclair/typebox").TString;
+export declare const authSchema: Type.TObject<{
+    accessKey: Type.TString;
 }>;
-export declare const cliConfigSchema: import("@sinclair/typebox").TObject<{
-    account: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        address: import("@sinclair/typebox").TString;
-        privateKey: import("@sinclair/typebox").TString;
+export declare const cliConfigSchema: Type.TObject<{
+    account: Type.TOptional<Type.TObject<{
+        address: Type.TString;
+        privateKey: Type.TString;
     }>>;
-    auth: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        accessKey: import("@sinclair/typebox").TString;
+    auth: Type.TOptional<Type.TObject<{
+        accessKey: Type.TString;
     }>>;
-    cookies: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnknown>;
-    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    providerUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    selectedStorage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    cookies: Type.TOptional<Type.TUnknown>;
+    name: Type.TOptional<Type.TString>;
+    providerUrl: Type.TOptional<Type.TString>;
+    selectedStorage: Type.TOptional<Type.TString>;
 }>;
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;

package/dist/config/config.schema.js

@@ -1,13 +1,4 @@
-import { FormatRegistry, Type } from '@sinclair/typebox';
-FormatRegistry.Set('url', (value) => {
-    try {
-        const u = new URL(value);
-        return u.protocol === 'http:' || u.protocol === 'https:';
-    }
-    catch {
-        return false;
-    }
-});
+import { Type } from 'typebox';
 export const accountSchema = Type.Object({
     address: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
     privateKey: Type.String({ pattern: '^0x[a-fA-F0-9]{64}$' }),

package/dist/config/resource.schema.d.ts

@@ -0,0 +1,31 @@
+import { ResourceType, StorageType } from '@super-protocol/provider-client';
+import { Type } from 'typebox';
+export declare const storageResourceSchema: Type.TObject<{
+    hash: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+        algo: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TEnum<typeof import("@super-protocol/dto-js").HashAlgorithm>;
+        hash: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        encoding: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TEnum<typeof import("@super-protocol/dto-js").Encoding>;
+    }>;
+    resource: Type.TObject<{
+        credentials: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TUnion<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TIntersect<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+            bucket: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+            prefix: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        }>, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+            token: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        }>]>, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TIntersect<[import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+            bucket: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+            prefix: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        }>, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+            accessKeyId: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+            secretKey: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+            endpoint: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        }>]>, import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TObject<{
+            bucket: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+            prefix: import("@sinclair/typebox", { with: { "resolution-mode": "require" } }).TString;
+        }>]>;
+        filepath: Type.TString;
+        storageType: Type.TEnum<[StorageType.S3, StorageType.FS, StorageType.StorJ]>;
+        type: Type.TEnum<[ResourceType.StorageProvider, ResourceType.Url]>;
+    }>;
+    size: Type.TNumber;
+}>;

package/dist/config/resource.schema.js

@@ -0,0 +1,14 @@
+import { HashSchema, StorageAccessCredentialsSchema } from '@super-protocol/dto-js';
+import { ResourceType, StorageType } from '@super-protocol/provider-client';
+import { Type } from 'typebox';
+const storageProviderResourceSchema = Type.Object({
+    credentials: StorageAccessCredentialsSchema,
+    filepath: Type.String({ minLength: 1 }),
+    storageType: Type.Enum(StorageType),
+    type: Type.Enum(ResourceType),
+});
+export const storageResourceSchema = Type.Object({
+    hash: HashSchema,
+    resource: storageProviderResourceSchema,
+    size: Type.Number({ minimum: 0 }),
+});

package/dist/constants.d.ts

@@ -2,3 +2,4 @@ export declare const FILE_ACCESS_PERMS = 384;
 export declare const DIR_ACCESS_PERMS = 448;
 export declare const PROVIDER_URL = "https://api.dp.superprotocol.com";
 export declare const REFRESH_TOKEN_URI = "/api/auth/refresh-access";
+export declare const S3_ENDPOINT = "https://gateway.storjshare.io";

package/dist/constants.js

@@ -4,3 +4,4 @@ export const FILE_ACCESS_PERMS = 0o600;
 export const DIR_ACCESS_PERMS = 0o700;
 export const PROVIDER_URL = 'https://api.dp.superprotocol.com';
 export const REFRESH_TOKEN_URI = '/api/auth/refresh-access';
+export const S3_ENDPOINT = 'https://gateway.storjshare.io';

package/dist/managers/account-manager.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { confirm, isCancel, password } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
+import { Value } from 'typebox/value';
 import { Retryable } from 'typescript-retry-decorator';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 import { accountSchema } from '../config/config.schema.js';

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

@@ -1,8 +1,8 @@
 import { confirm, isCancel, select } from '@clack/prompts';
 import { ux } from '@oclif/core';
-import { Value } from '@sinclair/typebox/value';
 import * as fs from 'node:fs';
 import path from 'node:path';
+import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
 import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
 import { getConfigName } from '../utils/helper.js';