@super-protocol/sp-cli 0.0.6 → 0.0.7

package/dist/commands/files/upload.js

@@ -4,19 +4,23 @@ 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 }),
+        path: Args.string({
+            description: 'file or directory to upload',
+            required: true,
+        }),
     };
     static description = 'Upload file or directory to remote storage';
-    static examples = [
-        '<%= config.bin %> <%= command.id %> ./file.txt',
-    ];
+    static 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,
+            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',
@@ -34,7 +38,7 @@ export default class FilesUpload extends BaseCommand {
         }),
         sync: Flags.boolean({
             default: false,
-            description: 'Sync mode: delete files in target that don\'t exist in source',
+            description: "Sync mode: delete files in target that don't exist in source",
             required: false,
         }),
     };
@@ -60,7 +64,7 @@ export default class FilesUpload extends BaseCommand {
                 sync: flags.sync,
                 withEncryption: !flags['skip-encryption'],
             }, ({ current, key, total }) => {
-                progress.advance(key, current / total * 100, `Uploading: ${key} [${current}/${total}]`);
+                progress.advance(key, (current / total) * 100, `Uploading: ${key} [${current}/${total}]`);
             });
         }
         catch (error) {

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

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-import { AddStorageDto } from '@super-protocol/provider-client';
+import type { Command } from '@oclif/core';
+import { type 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> {

package/dist/commands/storage/create.js

@@ -1,6 +1,6 @@
-import { Flags } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { Flags } from '@oclif/core';
 import { BaseStorageCommand } from './base.js';
 export default class StorageCreate extends BaseStorageCommand {
     static description = 'Create a new storage entry from file or interactive prompts.';

package/dist/commands/storage/select.js

@@ -3,15 +3,13 @@ import { StoragesUndefinedError } from '../../services/storage.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageSelect extends BaseStorageCommand {
     static description = 'Select a storage that will be used by subsequent commands.';
-    static examples = [
-        '<%= config.bin %> storage select',
-    ];
+    static examples = ['<%= config.bin %> storage select'];
     async run() {
         try {
             const storages = await this.storageService.requestStorages();
             const storageId = this.ensurePromptValue(await select({
                 message: 'Select storage',
-                options: storages.map(storage => ({
+                options: storages.map((storage) => ({
                     label: this.storageService.getLabel(storage),
                     value: storage.id,
                 })),
@@ -19,7 +17,7 @@ export default class StorageSelect extends BaseStorageCommand {
             if (!storageId) {
                 this.error('Storage ID is required');
             }
-            const storage = storages.find(storage => storage.id === storageId);
+            const storage = storages.find((storage) => storage.id === storageId);
             if (!storage) {
                 this.error(`Storage with ID: ${storageId} not found `);
             }

package/dist/commands/storage/show.js

@@ -8,9 +8,7 @@ const stripString = (str, chars) => {
 };
 export default class StorageShow extends BaseStorageCommand {
     static description = 'Show current selected storage';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-    ];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
         const storage = await this.storageService.getCurrentStorage();
         this.log(`Current storage: ${storage.isCentralized ? 'Super Cloud' : 'Custom storage'}`);
@@ -20,7 +18,7 @@ export default class StorageShow extends BaseStorageCommand {
         this.log(`- Prefix: ${storage.prefix}`);
         this.log(' -- Credentials --');
         if (storage.storageType === StorageType.S3) {
-            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '' } = storage.s3Credentials || {};
+            const { readAccessKeyId, readSecretAccessKey = '', writeAccessKeyId, writeSecretAccessKey = '', } = storage.s3Credentials || {};
             this.log(`    readAccessKeyId: ${readAccessKeyId}`);
             this.log(`    readSecretAccessKey: ${stripString(readSecretAccessKey, 5)}`);
             this.log(`    writeAccessKeyId: ${writeAccessKeyId}`);

package/dist/commands/storage/update.js

@@ -1,8 +1,8 @@
-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 { confirm, select, text } from '@clack/prompts';
+import { Flags } from '@oclif/core';
+import { StorageType, } from '@super-protocol/provider-client';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageUpdate extends BaseStorageCommand {
@@ -25,10 +25,14 @@ export default class StorageUpdate extends BaseStorageCommand {
         const { flags } = await this.parse(StorageUpdate);
         try {
             const shouldRequestStorages = !flags.fromFile || !flags.id;
-            const storages = shouldRequestStorages ? await this.storageService.requestStorages() : undefined;
+            const storages = shouldRequestStorages
+                ? await this.storageService.requestStorages()
+                : undefined;
             let storageId = flags.id;
             if (!storageId) {
-                const options = (storages || []).filter(cp => !cp.isCentralized).map(storage => ({
+                const options = (storages || [])
+                    .filter((cp) => !cp.isCentralized)
+                    .map((storage) => ({
                     label: `${storage.id} (${storage.storageType}) ${storage.bucket}/${storage.prefix} `,
                     value: storage.id,
                 }));
@@ -43,7 +47,7 @@ export default class StorageUpdate extends BaseStorageCommand {
             if (!storageId) {
                 this.error('Storage ID is required');
             }
-            const storageToUpdate = storages?.find(storage => storage.id === storageId);
+            const storageToUpdate = storages?.find((storage) => storage.id === storageId);
             if (flags.id && storages && !storageToUpdate) {
                 this.error(`Storage with ID ${storageId} not found`);
             }
@@ -72,8 +76,14 @@ export default class StorageUpdate extends BaseStorageCommand {
         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);
+        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');
         }
@@ -82,7 +92,11 @@ export default class StorageUpdate extends BaseStorageCommand {
         }
         if (payload.s3Credentials) {
             const { readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId, writeSecretAccessKey, } = payload.s3Credentials;
-            if (!readAccessKeyId || !readSecretAccessKey || !region || !writeAccessKeyId || !writeSecretAccessKey) {
+            if (!readAccessKeyId ||
+                !readSecretAccessKey ||
+                !region ||
+                !writeAccessKeyId ||
+                !writeSecretAccessKey) {
                 this.error('S3 credentials must include readAccessKeyId, readSecretAccessKey, region, writeAccessKeyId and writeSecretAccessKey');
             }
         }
@@ -120,7 +134,9 @@ export default class StorageUpdate extends BaseStorageCommand {
         return sanitized;
     }
     async loadStorageFromFile(filePath) {
-        const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(this.currentDir, 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);
@@ -166,10 +182,11 @@ export default class StorageUpdate extends BaseStorageCommand {
         const effectiveType = newStorageType ?? existingStorage?.storageType;
         const credentialsRequired = Boolean(newStorageType);
         if (effectiveType) {
-            const updateCredentials = credentialsRequired || this.ensurePromptValue(await confirm({
-                initialValue: false,
-                message: `Update ${effectiveType} credentials?`,
-            }));
+            const updateCredentials = credentialsRequired ||
+                this.ensurePromptValue(await confirm({
+                    initialValue: false,
+                    message: `Update ${effectiveType} credentials?`,
+                }));
             if (updateCredentials) {
                 if (effectiveType === StorageType.S3) {
                     payload.s3Credentials = await this.promptS3Credentials();

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

@@ -1,4 +1,4 @@
-import { SelectOptions } from '@clack/prompts';
+import { type SelectOptions } from '@clack/prompts';
 import { BaseCommand } from '../base.js';
 export default class WorkflowsExtendLease extends BaseCommand<typeof WorkflowsExtendLease> {
     static args: {

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

@@ -14,9 +14,17 @@ export default class WorkflowsExtendLease extends BaseCommand {
         '<%= 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' }),
+        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();
@@ -51,13 +59,14 @@ export default class WorkflowsExtendLease extends BaseCommand {
                 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 },
-                ],
-            });
+            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;

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

@@ -1,6 +1,5 @@
-import { Static, Type } from 'typebox';
+import { type 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,5 +1,4 @@
 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,4 +1,4 @@
-import { Static, Type } from 'typebox';
+import { type Static, Type } from 'typebox';
 export declare const accountSchema: Type.TObject<{
     address: Type.TString;
     privateKey: Type.TString;

package/dist/errors.d.ts

@@ -2,6 +2,8 @@ export declare class ConfigurationNotFoundError extends Error {
 }
 export declare class NotInitializedError extends Error {
 }
+export declare class AccountNotFoundError extends Error {
+}
 export declare class InvalidPrivateKeyError extends Error {
 }
 export declare class AuthorizationRequiredError extends Error {

package/dist/errors.js

@@ -2,6 +2,8 @@ export class ConfigurationNotFoundError extends Error {
 }
 export class NotInitializedError extends Error {
 }
+export class AccountNotFoundError extends Error {
+}
 export class InvalidPrivateKeyError extends Error {
 }
 export class AuthorizationRequiredError extends Error {

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

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

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

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

package/dist/hooks/finally/unlock-config.d.ts

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

package/dist/hooks/finally/unlock-config.js

@@ -0,0 +1,5 @@
+import { releaseCliInstanceLock } from '../../lib/cli-instance-lock.js';
+const hook = async () => {
+    await releaseCliInstanceLock();
+};
+export default hook;

package/dist/hooks/init/init-container.d.ts

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

package/dist/hooks/init/init-container.js

@@ -1,6 +1,5 @@
 import { AppContainer } from '../../lib/container.js';
-const hook = async function (opts) {
-    AppContainer
-        .initialize(process.cwd(), opts.config);
+const hook = async (opts) => {
+    AppContainer.initialize(process.cwd(), opts.config);
 };
 export default hook;

package/dist/hooks/init/lock-config.d.ts

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

package/dist/hooks/init/lock-config.js

@@ -0,0 +1,19 @@
+import path from 'node:path';
+import { mkdirSync } from 'node:fs';
+import { acquireCliInstanceLock } from '../../lib/cli-instance-lock.js';
+import { ConfigFileManager } from '../../managers/config-file-manager.js';
+const hook = async (opts) => {
+    const { context, config } = opts;
+    const lockFile = path.join(config.configDir, ConfigFileManager.CONFIG_FILE);
+    mkdirSync(config.configDir, { recursive: true });
+    try {
+        await acquireCliInstanceLock(lockFile);
+    }
+    catch (error) {
+        if (context) {
+            context.error(error, { exit: 1 });
+        }
+        throw error;
+    }
+};
+export default hook;

package/dist/hooks/prerun/auth.d.ts

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

package/dist/hooks/prerun/auth.js

@@ -0,0 +1,70 @@
+import { BaseCommand } from '../../commands/base.js';
+import { AppContainer } from '../../lib/container.js';
+import logger from '../../logger.js';
+import { AuthService } from '../../services/auth.service.js';
+const isBaseCommandClass = (commandClass) => commandClass.prototype instanceof BaseCommand;
+const getConfigFlag = (commandClass, argv) => {
+    if (!isBaseCommandClass(commandClass)) {
+        return undefined;
+    }
+    //Fix Parser.parse throws error Nonexistent flag we dont have the way to ignore it
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        if (token === '--config') {
+            const value = argv[index + 1];
+            return value && !value.startsWith('-') ? value : undefined;
+        }
+        if (token.startsWith('--config=')) {
+            const value = token.slice('--config='.length);
+            return value || undefined;
+        }
+    }
+    return undefined;
+};
+const hook = async (opts) => {
+    const { Command, config, context } = opts;
+    const commandId = Command.id;
+    const CommandClass = Command;
+    if (CommandClass.authenticate === false) {
+        return;
+    }
+    const pinoLogger = logger.getPino();
+    pinoLogger.info('Prerun hook auth called');
+    try {
+        const configFile = getConfigFlag(CommandClass, opts.argv ?? []);
+        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;
+        const credentials = await configManager.get('auth');
+        if (!credentials?.accessKey) {
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                context.error('Authorization not found. Please run: sp account login', { exit: 1 });
+            }
+            const args = configFile ? ['--config', configFile] : [];
+            pinoLogger.info({ commandId }, 'Authorization not found, redirecting to account:login');
+            await config.runCommand('account:login', args);
+        }
+        const authService = new AuthService(accountManager, configManager, providerClient, pinoLogger);
+        await authService.auth();
+        pinoLogger.debug({ commandId }, 'Authentication successful');
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('not initialized')) {
+            pinoLogger.debug({ commandId, err: error }, 'Container not initialized, skipping auth');
+            return;
+        }
+        pinoLogger.error({ commandId, err: error }, 'Authentication failed in prerun hook');
+        throw error;
+    }
+};
+export default hook;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { Interfaces, run as oclifRun } from '@oclif/core';
+import { type Interfaces, run as oclifRun } from '@oclif/core';
 export declare const run: (argv: string[], loadOptions?: Interfaces.LoadOptions | URL) => ReturnType<typeof oclifRun>;

package/dist/index.js

@@ -1,5 +1,5 @@
-import { run as oclifRun } from '@oclif/core';
 import { fileURLToPath } from 'node:url';
+import { run as oclifRun } from '@oclif/core';
 import logger from './logger.js';
 const normalizeLoadOptions = (loadOptions) => {
     if (!loadOptions) {

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

@@ -1,4 +1,4 @@
-import { IManager } from './manager.interface.js';
+import type { IManager } from './manager.interface.js';
 export interface IAccountManager extends IManager {
     createSign(nonce: string): Promise<string>;
     getAddress(): string;

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

@@ -1,5 +1,5 @@
-import { CliConfig } from '../config/config.schema.js';
-import { IManager } from './manager.interface.js';
+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>;
     load(): Promise<CliConfig>;

package/dist/lib/cli-instance-lock.d.ts

@@ -0,0 +1,2 @@
+export declare const acquireCliInstanceLock: (lockTarget: string) => Promise<void>;
+export declare const releaseCliInstanceLock: () => Promise<void>;

package/dist/lib/cli-instance-lock.js

@@ -0,0 +1,37 @@
+import { lock } from 'proper-lockfile';
+let release;
+let locked = false;
+const isLockHeldError = (error) => Boolean(error &&
+    typeof error === 'object' &&
+    'code' in error &&
+    error.code === 'ELOCKED');
+export const acquireCliInstanceLock = async (lockTarget) => {
+    if (locked) {
+        return;
+    }
+    try {
+        release = await lock(lockTarget, {
+            realpath: false,
+            retries: 0,
+            stale: 30_000,
+        });
+        locked = true;
+    }
+    catch (error) {
+        if (isLockHeldError(error)) {
+            const lockHeldError = Object.assign(new Error('Another instance of spcli is already running.'), { code: 'ELOCKED' });
+            throw lockHeldError;
+        }
+        throw error;
+    }
+};
+export const releaseCliInstanceLock = async () => {
+    if (!release) {
+        locked = false;
+        return;
+    }
+    const currentRelease = release;
+    release = undefined;
+    locked = false;
+    await currentRelease();
+};

package/dist/lib/container.d.ts

@@ -1,5 +1,5 @@
-import { Config } from '@oclif/core';
-import { ProviderClient } from '@super-protocol/provider-client';
+import type { Config } from '@oclif/core';
+import { type ProviderClient } from '@super-protocol/provider-client';
 import { AccountManager, ConfigFileManager, ConfigManager } from '../managers/index.js';
 interface RuntimeConfig {
     configFile?: string;
@@ -12,9 +12,10 @@ export declare class AppContainer {
     private _configFileManager?;
     private _configManager?;
     private _providerClient?;
-    private initPromises;
+    private providerClientOptions?;
     private readonly initQueue;
     private logger;
+    private providerClientInitToken;
     private runtimeConfigFile?;
     private constructor();
     static initialize(currentDir: string, config: Config): AppContainer;
@@ -28,12 +29,13 @@ export declare class AppContainer {
     initBlockchainConnector(): this;
     initConfigFileManager(rebuild?: boolean): this;
     initConfigManager(rebuild?: boolean): this;
-    initProviderClient({ enableAuth, enableCookies, rebuild }?: {
+    initProviderClient({ enableAuth, enableCookies, rebuild, }?: {
         enableAuth?: boolean;
         enableCookies?: boolean;
         rebuild?: boolean;
     }): this;
     setupRuntimeConfig(config: RuntimeConfig): this;
+    private getProviderClientForBootstrap;
     private queueInit;
     private waitFor;
 }