@super-protocol/sp-cli 0.0.9 → 0.0.10-beta

package/dist/commands/assets/get.js

@@ -0,0 +1,79 @@
+import { select } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { BaseAssetCommand } from './base.js';
+export default class AssetGet extends BaseAssetCommand {
+    static authenticate = false;
+    static description = 'Get information about an asset.';
+    static examples = [
+        '<%= config.bin %> assets get --id 11111111-1111-1111-1111-111111111111',
+        '<%= config.bin %> assets get --name "dataset-v1"',
+    ];
+    static flags = {
+        id: Flags.string({
+            char: 'i',
+            description: 'Asset ID to fetch',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Asset name to fetch',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AssetGet);
+        const asset = await this.resolveAsset(flags.id, flags.name);
+        this.assertDefined(asset, 'Asset not found');
+        this.printAssetInfo(asset);
+        return asset;
+    }
+    async resolveAsset(id, name) {
+        if (id) {
+            return this.assetService.findAssetById(id);
+        }
+        if (name) {
+            return this.assetService.findAssetByName(name);
+        }
+        const assets = await this.assetService.listAssets();
+        if (assets.length === 0) {
+            this.error('No assets available');
+        }
+        const selection = this.ensurePromptValue(await select({
+            message: 'Select asset',
+            options: assets.map((asset) => ({
+                label: `${asset.name} (${asset.id})`,
+                value: asset.id,
+            })),
+        }));
+        return assets.find((asset) => asset.id === selection);
+    }
+    printAssetInfo(asset) {
+        const formatValue = (value) => {
+            if (value === undefined || value === null || value === '') {
+                return 'N/A';
+            }
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            return String(value);
+        };
+        this.log(`ID: ${formatValue(asset.id)}`);
+        this.log(`Name: ${formatValue(asset.name)}`);
+        this.log(`Type: ${formatValue(asset.type)}`);
+        this.log(`Source: ${formatValue(asset.sourceType)}`);
+        this.log(`Tag: ${formatValue(asset.tag)}`);
+        this.log(`Hash: ${formatValue(asset.hash)}`);
+        this.log(`Size: ${formatValue(asset.size)}`);
+        this.log(`User: ${formatValue(asset.userId)}`);
+        this.log(`Created: ${formatValue(asset.createdAt)}`);
+        this.log(`Updated: ${formatValue(asset.updatedAt)}`);
+        const hardware = asset.hardwareRequirements;
+        if (hardware.length > 0) {
+            this.log('Hardware requirements:');
+            for (const requirement of hardware) {
+                this.log(`  ${JSON.stringify(requirement)}`);
+            }
+        }
+        else {
+            this.log('Hardware requirements: N/A');
+        }
+    }
+}

package/dist/commands/assets/list.d.ts

@@ -0,0 +1,7 @@
+import { BaseAssetCommand } from './base.js';
+export default class AssetList extends BaseAssetCommand<typeof AssetList> {
+    static authenticate: boolean;
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/assets/list.js

@@ -0,0 +1,33 @@
+import { printTable } from 'console-table-printer';
+import { BaseAssetCommand } from './base.js';
+export default class AssetList extends BaseAssetCommand {
+    static authenticate = false;
+    static description = 'List assets for the current user.';
+    static examples = ['<%= config.bin %> assets list'];
+    async run() {
+        const assets = await this.assetService.listAssets();
+        if (assets.length === 0) {
+            this.log('No assets found');
+            return;
+        }
+        const rows = assets.map((asset) => ({
+            id: asset.id,
+            name: asset.name,
+            size: asset.size ?? '',
+            sourceType: asset.sourceType,
+            tags: asset.tag ?? '',
+            type: asset.type,
+        }));
+        printTable(rows, {
+            columns: [
+                { name: 'name', title: 'Name' },
+                { name: 'id', title: 'ID' },
+                { name: 'type', title: 'Type' },
+                { name: 'sourceType', title: 'Source' },
+                { name: 'tags', title: 'Tags' },
+                { name: 'size', title: 'Size' },
+            ],
+            title: 'Assets',
+        });
+    }
+}

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

@@ -0,0 +1,44 @@
+import { type Asset, AssetType, SourceType } from '../../services/asset.service.js';
+import { BaseAssetCommand } from './base.js';
+export default class AssetUpdate extends BaseAssetCommand<typeof AssetUpdate> {
+    static authenticate: boolean;
+    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>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        newName: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<AssetType | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        sourceType: import("@oclif/core/interfaces").OptionFlag<SourceType | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        hash: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        size: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjBucket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjPath: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        storjToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Bucket: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3AccessKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3SecretKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Region: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        s3Endpoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerImage: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerRegistry: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerUsername: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dockerPassword: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubRepo: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubToken: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        githubBranch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsDocumentId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsApiKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        gdocsServiceAccountJson: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Asset>;
+    private loadAssetFromFile;
+    private promptAssetUpdate;
+    private resolveAsset;
+    private hasUpdateFlags;
+    private buildPayloadFromFlags;
+    private parseEnumValue;
+}

package/dist/commands/assets/update.js

@@ -0,0 +1,321 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { confirm, select, text } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { AssetType, SourceType, } from '../../services/asset.service.js';
+import { promptService } from '../../utils/prompt.service.js';
+import { BaseAssetCommand } from './base.js';
+const assetTypeOptions = Object.values(AssetType);
+const sourceTypeOptions = Object.values(SourceType);
+export default class AssetUpdate extends BaseAssetCommand {
+    static authenticate = false;
+    static description = 'Update an existing asset.';
+    static examples = [
+        '<%= config.bin %> assets update --id 11111111-1111-1111-1111-111111111111 --fromFile ./asset-update.json',
+        '<%= config.bin %> assets update --name "dataset-v1"',
+        '<%= config.bin %> assets update --id 11111111-1111-1111-1111-111111111111 --newName "dataset-v2"',
+        '<%= config.bin %> assets update --id 11111111-1111-1111-1111-111111111111 --sourceType s3 --s3Bucket b --s3Path p --s3AccessKey a --s3SecretKey s --s3Region us-east-1',
+    ];
+    static flags = {
+        fromFile: Flags.string({
+            char: 'f',
+            description: 'Path to a JSON file that contains asset update definition.',
+        }),
+        id: Flags.string({
+            char: 'i',
+            description: 'Asset ID to update',
+        }),
+        name: Flags.string({
+            char: 'n',
+            description: 'Asset name to update',
+        }),
+        newName: Flags.string({
+            description: 'New asset name',
+        }),
+        type: Flags.option({
+            char: 't',
+            description: 'New asset type',
+            options: assetTypeOptions,
+        })(),
+        sourceType: Flags.option({
+            char: 's',
+            description: 'New source type',
+            options: sourceTypeOptions,
+        })(),
+        tag: Flags.string({
+            description: 'New asset tag',
+        }),
+        hash: Flags.string({
+            description: 'New asset hash',
+        }),
+        size: Flags.string({
+            description: 'New asset size in bytes',
+        }),
+        storjBucket: Flags.string({
+            description: 'Storj bucket',
+        }),
+        storjPath: Flags.string({
+            description: 'Storj path',
+        }),
+        storjToken: Flags.string({
+            description: 'Storj access token',
+        }),
+        s3Bucket: Flags.string({
+            description: 'S3 bucket',
+        }),
+        s3Path: Flags.string({
+            description: 'S3 path',
+        }),
+        s3AccessKey: Flags.string({
+            description: 'S3 access key',
+        }),
+        s3SecretKey: Flags.string({
+            description: 'S3 secret key',
+        }),
+        s3Region: Flags.string({
+            description: 'S3 region',
+        }),
+        s3Endpoint: Flags.string({
+            description: 'S3 endpoint',
+        }),
+        dockerImage: Flags.string({
+            description: 'Docker image',
+        }),
+        dockerRegistry: Flags.string({
+            description: 'Docker registry',
+        }),
+        dockerUsername: Flags.string({
+            description: 'Docker username',
+        }),
+        dockerPassword: Flags.string({
+            description: 'Docker password',
+        }),
+        githubRepo: Flags.string({
+            description: 'GitHub repo (org/repo)',
+        }),
+        githubToken: Flags.string({
+            description: 'GitHub token',
+        }),
+        githubBranch: Flags.string({
+            description: 'GitHub branch',
+        }),
+        gdocsDocumentId: Flags.string({
+            description: 'Google Docs document ID',
+        }),
+        gdocsApiKey: Flags.string({
+            description: 'Google Docs API key',
+        }),
+        gdocsServiceAccountJson: Flags.string({
+            description: 'Google Docs service account JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(AssetUpdate);
+        if (!promptService.isInteractive && !flags.id && !flags.name) {
+            this.error('Provide --id or --name when running with --no-tty.');
+        }
+        const asset = await this.resolveAsset(flags.id, flags.name);
+        this.assertDefined(asset, 'Asset not found');
+        const hasUpdateFlags = this.hasUpdateFlags(flags);
+        if (!flags.fromFile && !hasUpdateFlags && !promptService.isInteractive) {
+            this.error('Provide --fromFile or update flags when running with --no-tty.');
+        }
+        let payload = flags.fromFile ? await this.loadAssetFromFile(flags.fromFile) : undefined;
+        if (hasUpdateFlags) {
+            const flagPayload = this.buildPayloadFromFlags(flags, asset);
+            payload = this.assetService.validateUpdatePayload(payload ? { ...payload, ...flagPayload } : flagPayload);
+        }
+        if (!payload) {
+            payload = await this.promptAssetUpdate(asset);
+        }
+        const effectiveType = payload.type ?? asset.type;
+        const effectiveSourceType = payload.sourceType ?? asset.sourceType;
+        this.assertSourceTypeAllowed(effectiveType, effectiveSourceType);
+        try {
+            const updated = await this.assetService.updateAsset(asset.id, payload);
+            this.log(`Asset updated: ${updated.id}`);
+            return updated;
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    async loadAssetFromFile(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.assetService.validateUpdatePayload(parsed);
+        }
+        catch (error) {
+            this.error(`Failed to load asset update definition: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async promptAssetUpdate(existing) {
+        const payload = {};
+        const name = this.ensurePromptValue(await text({
+            defaultValue: existing.name,
+            message: 'Asset name (leave empty to keep current)',
+        })).trim();
+        if (name && name !== existing.name) {
+            payload.name = name;
+        }
+        const changeType = this.ensurePromptValue(await confirm({
+            initialValue: false,
+            message: `Change asset type? (current: ${existing.type})`,
+        }));
+        if (changeType) {
+            payload.type = this.ensurePromptValue(await select({
+                message: 'Select asset type',
+                options: [
+                    { label: 'Data', value: AssetType.DATA },
+                    { label: 'Image', value: AssetType.IMAGE },
+                    { label: 'Output', value: AssetType.OUTPUT },
+                ],
+            }));
+        }
+        const changeSource = this.ensurePromptValue(await confirm({
+            initialValue: false,
+            message: `Change source type? (current: ${existing.sourceType})`,
+        }));
+        if (changeSource) {
+            const effectiveType = payload.type ?? existing.type;
+            const allowedSourceTypes = this.getAllowedSourceTypes(effectiveType);
+            const sourceTypeOptions = [
+                { label: 'StorJ', value: SourceType.STORJ },
+                { label: 'S3', value: SourceType.S3 },
+                { label: 'DockerHub', value: SourceType.DOCKERHUB },
+                { label: 'GitHub', value: SourceType.GITHUB },
+                { label: 'Google Docs', value: SourceType.GOOGLE_DOCS },
+            ].filter((option) => allowedSourceTypes.includes(option.value));
+            payload.sourceType = this.ensurePromptValue(await select({
+                message: 'Select source type',
+                options: sourceTypeOptions,
+            }));
+        }
+        const updateCredentials = this.ensurePromptValue(await confirm({
+            initialValue: false,
+            message: 'Update credentials?',
+        }));
+        if (updateCredentials) {
+            const effectiveSourceType = payload.sourceType ?? existing.sourceType;
+            payload.credentials = await this.promptCredentials(effectiveSourceType);
+            payload.sourceType = effectiveSourceType;
+        }
+        const tagRaw = this.ensurePromptValue(await text({
+            defaultValue: existing.tag ?? '',
+            message: 'Tag (leave empty to keep current)',
+        })).trim();
+        if (tagRaw && tagRaw !== (existing.tag ?? '')) {
+            payload.tag = tagRaw;
+        }
+        const hashRaw = this.ensurePromptValue(await text({
+            defaultValue: existing.hash ?? '',
+            message: 'Hash (leave empty to keep current)',
+        })).trim();
+        if (hashRaw && hashRaw !== existing.hash) {
+            payload.hash = hashRaw;
+        }
+        const sizeRaw = this.ensurePromptValue(await text({
+            defaultValue: existing.size !== undefined ? String(existing.size) : '',
+            message: 'Size in bytes (leave empty to keep current)',
+            validate(value) {
+                if (!value?.trim()) {
+                    return undefined;
+                }
+                const size = Number(value);
+                if (!Number.isFinite(size) || size < 0) {
+                    return 'Size must be a positive number';
+                }
+                return undefined;
+            },
+        }));
+        const size = this.parseSizeInput(sizeRaw);
+        if (size !== undefined && size !== existing.size) {
+            payload.size = size;
+        }
+        if (Object.keys(payload).length === 0) {
+            this.error('No changes provided');
+        }
+        return payload;
+    }
+    async resolveAsset(id, name) {
+        if (id) {
+            return this.assetService.findAssetById(id);
+        }
+        if (name) {
+            return this.assetService.findAssetByName(name);
+        }
+        const assets = await this.assetService.listAssets();
+        if (assets.length === 0) {
+            this.error('No assets available');
+        }
+        const selection = this.ensurePromptValue(await select({
+            message: 'Select asset to update',
+            options: assets.map((asset) => ({
+                label: `${asset.name} (${asset.id})`,
+                value: asset.id,
+            })),
+        }));
+        return assets.find((asset) => asset.id === selection);
+    }
+    hasUpdateFlags(flags) {
+        return Boolean(flags.newName ||
+            flags.type ||
+            flags.sourceType ||
+            flags.tag ||
+            flags.hash ||
+            flags.size ||
+            this.hasCredentialsFlags(flags));
+    }
+    buildPayloadFromFlags(flags, existing) {
+        const payload = {};
+        const newName = flags.newName?.trim();
+        if (newName) {
+            payload.name = newName;
+        }
+        const rawType = flags.type?.trim();
+        if (rawType) {
+            payload.type = this.parseEnumValue(rawType, assetTypeOptions, 'type');
+        }
+        const rawSourceType = flags.sourceType?.trim();
+        if (rawSourceType) {
+            payload.sourceType = this.parseEnumValue(rawSourceType, sourceTypeOptions, 'sourceType');
+        }
+        const hasCredentialFlags = this.hasCredentialsFlags(flags);
+        if (hasCredentialFlags) {
+            const effectiveSourceType = payload.sourceType ?? existing.sourceType;
+            payload.credentials = this.buildCredentialsFromFlags(effectiveSourceType, flags);
+            payload.sourceType = effectiveSourceType;
+        }
+        else if (rawSourceType) {
+            this.error(`Provide credentials flags for sourceType "${rawSourceType}".`);
+        }
+        const tag = flags.tag?.trim();
+        if (tag) {
+            payload.tag = tag;
+        }
+        const hash = flags.hash?.trim();
+        if (hash) {
+            payload.hash = hash;
+        }
+        if (flags.size !== undefined) {
+            const size = this.parseSizeInput(flags.size);
+            if (size !== undefined) {
+                payload.size = size;
+            }
+        }
+        if (Object.keys(payload).length === 0) {
+            this.error('No updates provided via flags');
+        }
+        return payload;
+    }
+    parseEnumValue(value, allowed, field) {
+        const normalized = value.trim().toLowerCase();
+        const match = allowed.find((candidate) => candidate.toLowerCase() === normalized);
+        this.assertDefined(match, `Invalid ${field}: ${value}. Allowed: ${allowed.join(', ')}`);
+        return match;
+    }
+}

package/dist/commands/base.d.ts

@@ -13,5 +13,6 @@ export declare abstract class BaseCommand<T extends typeof Command> extends Comm
     protected logger: pino.BaseLogger;
     constructor(argv: string[], config: Config);
     protected ensurePromptValue<T>(value: symbol | T, errorMessage?: string): T;
+    protected assertDefined<T>(value: T | null | undefined, message: string): asserts value is T;
     init(): Promise<void>;
 }

package/dist/commands/base.js

@@ -49,6 +49,11 @@ export class BaseCommand extends Command {
             this.error(error instanceof Error ? error.message : String(error));
         }
     }
+    assertDefined(value, message) {
+        if (value === undefined || value === null) {
+            this.error(message);
+        }
+    }
     async init() {
         await super.init();
         const allFlags = { ...this.ctor.flags, ...super.ctor.baseFlags };

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

@@ -6,10 +6,6 @@ export declare const accountSchema: Type.TObject<{
 export declare const authSchema: Type.TObject<{
     accessKey: Type.TString;
 }>;
-export declare const blockchainSchema: Type.TObject<{
-    blockchainUrl: Type.TOptional<Type.TString>;
-    contractAddress: Type.TString;
-}>;
 export declare const cliConfigSchema: Type.TObject<{
     account: Type.TOptional<Type.TObject<{
         address: Type.TString;
@@ -18,16 +14,11 @@ export declare const cliConfigSchema: Type.TObject<{
     auth: Type.TOptional<Type.TObject<{
         accessKey: Type.TString;
     }>>;
-    blockchain: Type.TOptional<Type.TObject<{
-        blockchainUrl: Type.TOptional<Type.TString>;
-        contractAddress: Type.TString;
-    }>>;
-    cookies: Type.TOptional<Type.TUnknown>;
+    authUrl: Type.TOptional<Type.TString>;
     name: Type.TOptional<Type.TString>;
-    providerUrl: Type.TOptional<Type.TString>;
+    swarmUrl: Type.TOptional<Type.TString>;
     selectedStorage: Type.TOptional<Type.TString>;
 }>;
 export type CliConfig = Static<typeof cliConfigSchema>;
 export type Account = Static<typeof accountSchema>;
 export type Auth = Static<typeof authSchema>;
-export type Blockchain = Static<typeof blockchainSchema>;

package/dist/config/config.schema.js

@@ -6,16 +6,11 @@ export const accountSchema = Type.Object({
 export const authSchema = Type.Object({
     accessKey: Type.String(),
 });
-export const blockchainSchema = Type.Object({
-    blockchainUrl: Type.Optional(Type.String({ format: 'url' })),
-    contractAddress: Type.String({ pattern: '^0x[a-fA-F0-9]{40}$' }),
-});
 export const cliConfigSchema = Type.Object({
     account: Type.Optional(accountSchema),
     auth: Type.Optional(authSchema),
-    blockchain: Type.Optional(blockchainSchema),
-    cookies: Type.Optional(Type.Unknown()),
+    authUrl: Type.Optional(Type.String({ format: 'url' })),
     name: Type.Optional(Type.String()),
-    providerUrl: Type.Optional(Type.String({ format: 'url' })),
+    swarmUrl: Type.Optional(Type.String({ format: 'url' })),
     selectedStorage: Type.Optional(Type.String({ maxLength: 36, minLength: 36 })),
 });

package/dist/constants.d.ts

@@ -1,8 +1,8 @@
 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 SWARM_URL = "https://api.swarm.superprotocol.com";
+export declare const AUTH_PATH = "/api/auth";
 export declare const S3_ENDPOINT = "https://gateway.storjshare.io";
 export declare const S3_REGION = "us-east-1";
-export declare const DEFAULT_USER_CONFIG_FILE = "default.config.json";
+export declare const DEFAULT_USER_CONFIG_FILE = "default.json";
 export declare const DEFAULT_USER_CONFIG_NAME = "Default";

package/dist/constants.js

@@ -2,9 +2,9 @@
 export const FILE_ACCESS_PERMS = 0o600;
 //  Directory permissions.     'drwx------'
 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 SWARM_URL = 'https://api.swarm.superprotocol.com';
+export const AUTH_PATH = '/api/auth';
 export const S3_ENDPOINT = 'https://gateway.storjshare.io';
 export const S3_REGION = 'us-east-1';
-export const DEFAULT_USER_CONFIG_FILE = 'default.config.json';
+export const DEFAULT_USER_CONFIG_FILE = 'default.json';
 export const DEFAULT_USER_CONFIG_NAME = 'Default';

package/dist/errors.d.ts

@@ -8,5 +8,3 @@ export declare class InvalidPrivateKeyError extends Error {
 }
 export declare class AuthorizationRequiredError extends Error {
 }
-export declare class ProviderClientError extends Error {
-}

package/dist/errors.js

@@ -8,5 +8,3 @@ export class InvalidPrivateKeyError extends Error {
 }
 export class AuthorizationRequiredError extends Error {
 }
-export class ProviderClientError extends Error {
-}

package/dist/hooks/prerun/auth.js

@@ -39,13 +39,8 @@ const hook = async (opts) => {
         const container = configFile
             ? AppContainer.container.setupRuntimeConfig({ configFile })
             : AppContainer.container;
-        await container
-            .initConfigFileManager()
-            .initConfigManager()
-            .initAccountManager()
-            .initProviderClient({ enableAuth: false, enableCookies: true })
-            .build();
-        const { configManager, accountManager, providerClient } = container;
+        await container.initConfigFileManager().initConfigManager().initAccountManager().build();
+        const { configManager, accountManager } = container;
         const credentials = await configManager.get('auth');
         if (!credentials?.accessKey) {
             if (!isInteractiveMode()) {
@@ -55,7 +50,7 @@ const hook = async (opts) => {
             pinoLogger.info({ commandId }, 'Authorization not found, redirecting to account:login');
             await config.runCommand('account:login', args);
         }
-        const authService = new AuthService(accountManager, configManager, providerClient, pinoLogger);
+        const authService = new AuthService(accountManager, configManager, pinoLogger);
         await authService.auth();
         pinoLogger.debug({ commandId }, 'Authentication successful');
     }

package/dist/interfaces/config-manager.interface.d.ts

@@ -1,7 +1,9 @@
 import type { CliConfig } from '../config/config.schema.js';
 import type { IManager } from './manager.interface.js';
 export interface IConfigManager extends IManager {
-    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
+    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): undefined | V;
+    getAuthUrl(): string | undefined;
+    getSwarmUrl(): string;
     load(): Promise<CliConfig>;
     save(): Promise<void>;
     set<K extends keyof CliConfig, V extends CliConfig[K]>(key: K, value: V): Promise<void>;