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

package/dist/commands/storage/update.js

@@ -1,204 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { Flags } from '@oclif/core';
-import { StorageType, } from '@super-protocol/provider-client';
-import { StoragesUndefinedError } from '../../services/storage.service.js';
-import { promptService } from '../../utils/prompt.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 = await promptService.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 = (await promptService.text({
-            defaultValue: existingStorage?.bucket ?? '',
-            message: 'Bucket name (leave empty to keep current)',
-        })).trim();
-        if (bucket) {
-            payload.bucket = bucket;
-        }
-        const prefix = (await promptService.text({
-            defaultValue: existingStorage?.prefix ?? '',
-            message: 'Prefix (leave empty to keep current)',
-        })).trim();
-        if (prefix) {
-            payload.prefix = prefix;
-        }
-        let newStorageType;
-        const shouldChangeType = await promptService.confirm({
-            initialValue: false,
-            message: existingStorage
-                ? `Change storage type? (current: ${existingStorage.storageType})`
-                : 'Change storage type?',
-        });
-        if (shouldChangeType) {
-            newStorageType = await promptService.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 ||
-                (await promptService.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

@@ -1,17 +0,0 @@
-import { type SelectOptions } from '../../utils/prompt.service.js';
-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>;
-}

package/dist/commands/workflows/extend-lease.js

@@ -1,102 +0,0 @@
-import { Args, Flags } from '@oclif/core';
-import { Orders } from '@super-protocol/sdk-js';
-import { formatEther, parseEther } from 'viem/utils';
-import { promptService } from '../../utils/prompt.service.js';
-import { BaseCommand } from '../base.js';
-export default class WorkflowsExtendLease extends BaseCommand {
-    static args = {
-        orderId: Args.string({ description: 'Order ID', required: true }),
-    };
-    static description = 'Replenish deposit for a workflow to extend its lease time';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> <orderId> --sppi 1.5',
-        '<%= config.bin %> <%= command.id %> <orderId> --minutes 120',
-        '<%= config.bin %> <%= command.id %> <orderId> --sppi 2 --yes',
-    ];
-    static flags = {
-        minutes: Flags.integer({
-            description: 'Time to extend order in minutes (automatically calculates tokens)',
-        }),
-        sppi: Flags.string({
-            description: 'SPPI token amount to add to the order',
-        }),
-        yes: Flags.boolean({
-            char: 'y',
-            default: false,
-            description: 'Skip confirmation prompt',
-        }),
-    };
-    async init() {
-        await super.init();
-        await this.container
-            .initConfigManager()
-            .initAccountManager()
-            .initBlockchainConnector()
-            .initProviderClient({ enableAuth: true })
-            .build();
-    }
-    async run() {
-        const { args, flags } = await this.parse(WorkflowsExtendLease);
-        const { providerClient } = this.container;
-        try {
-            this.logger.info(`Checking order ${args.orderId}`);
-            // Get actual per-hour price from blockchain
-            const amountPerHour = await Orders.calculateWorkflowPerHourPrice(args.orderId);
-            let tokenAmount;
-            let minutes;
-            if (flags.minutes) {
-                // Calculate token amount from minutes
-                tokenAmount = (BigInt(amountPerHour) * BigInt(flags.minutes)) / 60n;
-                minutes = flags.minutes;
-            }
-            else if (flags.sppi) {
-                // Use provided SPPI amount
-                tokenAmount = parseEther(flags.sppi);
-                minutes = Number((tokenAmount * 60n) / BigInt(amountPerHour));
-            }
-            else {
-                this.error('Please provide either --sppi or --minutes flag to specify the replenishment amount');
-                return;
-            }
-            // Confirmation prompt
-            const confirmed = this.flags.yes ||
-                (await this.selectPrompt({
-                    message: `Deposit will be replenished by ${formatEther(tokenAmount)} SPPI. Order time is extended by ${minutes} minutes. Confirm?`,
-                    options: [
-                        { label: 'Yes', value: true },
-                        { label: 'No', value: false },
-                    ],
-                }));
-            if (!confirmed) {
-                this.logger.info('Operation cancelled by user');
-                return;
-            }
-            // Call API to replenish deposit
-            const { data, error } = await providerClient.POST('/api/workflows/{orderId}/replenish', {
-                body: {
-                    amount: tokenAmount.toString(),
-                },
-                params: {
-                    path: {
-                        orderId: args.orderId,
-                    },
-                },
-            });
-            if (error) {
-                this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
-                this.error(`Failed to replenish deposit: ${error.message || 'Unknown error'}`);
-                return;
-            }
-            this.logger.info({ data }, 'Deposit replenished successfully');
-            this.log('Deposit replenished successfully');
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error({ error }, `Order ${args.orderId} was not replenished`);
-            this.error(`Order ${args.orderId} was not replenished: ${errorMessage}`);
-        }
-    }
-    async selectPrompt(options) {
-        return promptService.select(options);
-    }
-}

package/dist/hooks/finally/shutdown-blockchain.d.ts

@@ -1,3 +0,0 @@
-import type { Hook } from '@oclif/core';
-declare const hook: Hook<'finally'>;
-export default hook;

package/dist/hooks/finally/shutdown-blockchain.js

@@ -1,8 +0,0 @@
-import { BlockchainConnector } from '@super-protocol/sdk-js';
-const hook = async () => {
-    const connector = BlockchainConnector.getInstance();
-    if (connector.isInitialized()) {
-        connector.shutdown();
-    }
-};
-export default hook;

package/dist/middlewares/auth-middleware.d.ts

@@ -1,9 +0,0 @@
-import type { MiddlewareFn, ProviderClient } from '@super-protocol/provider-client';
-import type pino from 'pino';
-import type { Auth } from '../config/config.schema.js';
-interface CredentialsStorage {
-    getCredentials(): Promise<Auth | undefined>;
-    setCredentials(auth: Auth): void;
-}
-export declare function createAuthMiddleware(configManager: CredentialsStorage, providerClient: ProviderClient, logger: pino.BaseLogger): Promise<ReturnType<MiddlewareFn>>;
-export {};

package/dist/middlewares/auth-middleware.js

@@ -1,91 +0,0 @@
-import { decode } from 'jsonwebtoken';
-import { REFRESH_TOKEN_URI } from '../constants.js';
-import { AuthorizationRequiredError } from '../errors.js';
-function isAccessKeyExpired(accessKey) {
-    try {
-        const payload = decode(accessKey);
-        if (!payload || typeof payload.exp !== 'number') {
-            return true;
-        }
-        const now = Math.floor(Date.now() / 1000);
-        return now >= payload.exp;
-    }
-    catch {
-        return true;
-    }
-}
-export async function createAuthMiddleware(configManager, providerClient, logger) {
-    let auth;
-    let refreshPromise;
-    const performRefresh = async () => {
-        if (!auth) {
-            return undefined;
-        }
-        logger.info('Performed refresh token');
-        let refreshResult;
-        try {
-            refreshResult = await providerClient.POST(REFRESH_TOKEN_URI);
-        }
-        catch (error) {
-            logger.error({ err: error }, 'failure refresh token');
-            const message = error instanceof Error ? error.message : 'Unknown error';
-            throw new AuthorizationRequiredError(`Unable to reach provider API: ${message}`);
-        }
-        const { data, error: refreshError } = refreshResult;
-        if (refreshError) {
-            logger.error({ refreshError }, 'Failure refresh response');
-            throw new AuthorizationRequiredError(`Unable to refresh access key: ${JSON.stringify(refreshError)}`);
-        }
-        if (!data || !data.accessToken) {
-            logger.error({ response: data }, 'Server returned incorrect response');
-            throw new AuthorizationRequiredError('Provider returned an unexpected refresh response.');
-        }
-        const updatedAuth = {
-            accessKey: data.accessToken,
-        };
-        await setCredentials(updatedAuth);
-        return updatedAuth.accessKey;
-    };
-    const refreshAccessKey = async () => {
-        if (!auth) {
-            return undefined;
-        }
-        if (!refreshPromise) {
-            refreshPromise = performRefresh().finally(() => {
-                refreshPromise = undefined;
-            });
-        }
-        return refreshPromise;
-    };
-    const ensureAccessKey = async (forceRefresh = false) => {
-        if (!auth) {
-            return undefined;
-        }
-        const { accessKey } = auth;
-        if (!forceRefresh && accessKey && !isAccessKeyExpired(accessKey)) {
-            return accessKey;
-        }
-        return refreshAccessKey();
-    };
-    const setCredentials = async (newAuth) => {
-        auth = newAuth;
-        await configManager.setCredentials(newAuth);
-    };
-    auth = await configManager.getCredentials();
-    if (!auth) {
-        throw new AuthorizationRequiredError('Authorization not found please login first');
-    }
-    const middleware = {
-        async onRequest({ request }) {
-            if (request.url.endsWith(REFRESH_TOKEN_URI)) {
-                return request;
-            }
-            const accessToken = await ensureAccessKey();
-            if (accessToken) {
-                request.headers.set('Authorization', `Bearer ${accessToken}`);
-            }
-            return request;
-        },
-    };
-    return middleware;
-}

package/dist/middlewares/cookies-middleware.d.ts

@@ -1,8 +0,0 @@
-import type { MiddlewareFn } from '@super-protocol/provider-client';
-import type pino from 'pino';
-interface CookiesStorage {
-    getCookies(): Promise<unknown>;
-    setCookies(cookies: unknown): Promise<void>;
-}
-export declare const createCookieMiddleware: (configManager: CookiesStorage, logger: pino.BaseLogger, baseUrl: string) => Promise<ReturnType<MiddlewareFn>>;
-export {};

package/dist/middlewares/cookies-middleware.js

@@ -1,80 +0,0 @@
-import { CookieJar } from 'tough-cookie';
-const extractSetCookieHeaders = (response) => {
-    const cookiesFromGetter = response.headers.getSetCookie?.();
-    if (cookiesFromGetter && cookiesFromGetter.length > 0) {
-        return cookiesFromGetter;
-    }
-    // For capability to nodejs < 20
-    const headersWithRaw = response.headers;
-    const raw = headersWithRaw.raw?.();
-    const headerList = raw?.['set-cookie'];
-    if (headerList && headerList.length > 0) {
-        return headerList;
-    }
-    const headerValue = response.headers.get('set-cookie');
-    return headerValue ? [headerValue] : [];
-};
-export const createCookieMiddleware = async (configManager, logger, baseUrl) => {
-    let cookieJar = new CookieJar();
-    const loadCookieJar = async () => {
-        try {
-            const stored = await configManager.getCookies();
-            if (stored && typeof stored === 'object') {
-                cookieJar = CookieJar.fromJSON(stored);
-                return;
-            }
-        }
-        catch (error) {
-            logger.warn({ err: error }, 'Failed to load cookies from config');
-        }
-        cookieJar = new CookieJar();
-    };
-    const persistCookieJar = async () => {
-        try {
-            const serialized = cookieJar.toJSON();
-            await configManager.setCookies(serialized);
-        }
-        catch (error) {
-            logger.warn({ err: error }, 'Failed to persist cookies');
-        }
-    };
-    await loadCookieJar();
-    return {
-        async onRequest({ request }) {
-            const requestUrl = request.url ?? baseUrl;
-            try {
-                const cookieHeader = await cookieJar.getCookieString(requestUrl);
-                if (cookieHeader) {
-                    request.headers.set('Cookie', cookieHeader);
-                }
-            }
-            catch (error) {
-                logger.warn({ err: error, requestUrl }, 'Failed to attach cookies to request');
-            }
-        },
-        async onResponse({ response }) {
-            const rawCookies = extractSetCookieHeaders(response);
-            if (rawCookies.length === 0) {
-                return response;
-            }
-            const targetUrl = response.url || baseUrl;
-            const updates = await Promise.all(rawCookies.map(async (rawCookie) => {
-                try {
-                    const storedCookie = await cookieJar.setCookie(rawCookie, targetUrl);
-                    if (storedCookie) {
-                        logger.debug({ cookie: storedCookie.key }, 'Updated cookie from response');
-                    }
-                    return true;
-                }
-                catch (error) {
-                    logger.warn({ err: error, rawCookie }, 'Failed to store cookie from response');
-                    return false;
-                }
-            }));
-            if (updates.some(Boolean)) {
-                await persistCookieJar();
-            }
-            return response;
-        },
-    };
-};

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

@@ -1,73 +0,0 @@
-import { type EncryptionWithIV, type Resource, type RuntimeInputInfo } from '@super-protocol/dto-js';
-import { type AddStorageDto, type ProviderClient, type StorageResponseDto, type UpdateStorageDto } from '@super-protocol/provider-client';
-import type pino from 'pino';
-export declare class StorageError extends Error {
-}
-export declare class StoragesUndefinedError extends StorageError {
-}
-export declare class StorageCreateError extends StorageError {
-}
-export declare class StorageUpdateError extends StorageError {
-}
-export declare class StorageGetError extends StorageError {
-}
-type IUploadParams = {
-    localPath: string;
-    maximumConcurrent?: number;
-    metadataPath?: string;
-    outputPath?: string;
-    remotePath?: string;
-    sync?: boolean;
-    withEncryption: boolean;
-};
-type IDownloadParams = {
-    downloadPath: string;
-    maximumConcurrent?: number;
-    resourcePath: string;
-};
-export type ResourceFile = Partial<Pick<RuntimeInputInfo, 'args' | 'hardwareContext' | 'hash' | 'signatureKeyHash'>> & {
-    encryption?: EncryptionWithIV;
-    resource: Resource;
-};
-type ProgressCb = (arg: {
-    current: number;
-    key: string;
-    total: number;
-}) => void;
-export declare const generateExternalId: () => string;
-export declare class StorageService {
-    private readonly providerClient;
-    private readonly logger;
-    constructor(providerClient: ProviderClient, logger: pino.BaseLogger);
-    createStorage(storage: AddStorageDto): Promise<StorageResponseDto>;
-    download(params: IDownloadParams, progressCb: ProgressCb): Promise<void>;
-    getCentralizedStorage(): Promise<StorageResponseDto>;
-    getCurrentStorage(): Promise<StorageResponseDto>;
-    getLabel(storage: StorageResponseDto): string;
-    hasStorage(): Promise<boolean>;
-    initCentralizedStorage(): 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;
-    }>;
-    requestStorages(): Promise<StorageResponseDto[]>;
-    saveStorage(selectedStorage: string): Promise<{
-        activeStorageId: string;
-        createdAt: string;
-        decentralizedStorageId?: string;
-        id: string;
-        updatedAt: string;
-        userId: string;
-    } | undefined>;
-    updateStorage(id: string, storage: UpdateStorageDto): Promise<StorageResponseDto>;
-    upload(params: IUploadParams, progressCb: ProgressCb): Promise<void>;
-    private getStorageCredentials;
-}
-export {};