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

package/dist/commands/account/login.js

@@ -1,16 +1,15 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
 import { Flags } from '@oclif/core';
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
-import { PROVIDER_URL } from '../../constants.js';
+import { generatePrivateKey } from 'viem/accounts';
+import { SWARM_URL } from '../../constants.js';
+import { AccountService } from '../../services/account.service.js';
 import { AuthService } from '../../services/auth.service.js';
-import { StorageService } from '../../services/storage.service.js';
-import { getConfigNameFromCredentials } from '../../utils/helper.js';
+import { getConfigName, preparePath } from '../../utils/helper.js';
 import { promptService } from '../../utils/prompt.service.js';
 import { BaseAccountCommand } from './base.js';
 export default class AccountLoginCommand extends BaseAccountCommand {
     static aliases = ['login'];
     static authenticate = false;
+    static summary = 'Login and account creation for SuperProtocol';
     static description = 'Login to SuperProtocol (sign up or sign in).';
     static examples = [
         `<%= config.bin %> <%= command.id %>
@@ -23,8 +22,15 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         privateKey: Flags.string({
             description: 'Account private key used for authentication',
         }),
+        path: Flags.string({
+            description: 'Path to account(configuration) file to import',
+        }),
         url: Flags.string({
-            description: 'Provider base URL',
+            description: 'Swarm Api URL',
+            hidden: true,
+        }),
+        authUrl: Flags.string({
+            description: 'Auth URL',
             hidden: true,
         }),
         yes: Flags.boolean({
@@ -33,49 +39,40 @@ export default class AccountLoginCommand extends BaseAccountCommand {
             description: 'Skip questions (generate keys when needed).',
         }),
     };
-    configFileManager;
+    accountService;
     shouldSkipLogin = false;
     async inputPrompt(options) {
         return promptService.text(options);
     }
     async checkStorage() {
-        await this.container
-            .initProviderClient({ enableAuth: true, enableCookies: true, rebuild: true })
-            .build();
-        const { providerClient } = this.container;
-        const storageService = new StorageService(providerClient, this.logger);
-        if (!(await storageService.hasStorage())) {
-            this.logger.info('Requesting default storage');
-            const { id, isCentralized, storageType } = await storageService.getCentralizedStorage();
-            this.logger.info({ id, isCentralized, storageType }, 'Requested new storage');
-            await storageService.saveStorage(id);
-        }
+        this.logger.info('Storage initialization skipped (mock)');
     }
     async init() {
         await super.init();
         await this.container.initConfigFileManager().build();
-        this.configFileManager = this.container.configFileManager;
+        this.accountService = new AccountService(this.container.configFileManager);
         await this.resolveConfiguration();
         if (this.shouldSkipLogin) {
             return;
         }
         await this.initAccountContext({
             assumeYes: this.flags.yes,
-            enableAuth: false,
-            enableCookies: true,
         });
     }
     async run() {
         if (this.shouldSkipLogin) {
             return { account: undefined, success: false };
         }
-        const { accountManager, configManager, providerClient } = this.container;
-        const authService = new AuthService(accountManager, configManager, providerClient, this.logger);
+        const { accountManager, configManager } = this.container;
+        const authService = new AuthService(accountManager, configManager, this.logger);
         try {
             await authService.auth({ force: true });
         }
         catch (error) {
-            this.error(error, { exit: 1 });
+            if (error instanceof Error) {
+                this.error(error, { exit: 1 });
+            }
+            this.error(String(error), { exit: 1 });
         }
         try {
             await this.checkStorage();
@@ -90,7 +87,7 @@ export default class AccountLoginCommand extends BaseAccountCommand {
     }
     async askName(fallback) {
         const value = await this.inputPrompt({
-            message: 'Configuration name:',
+            message: 'Account name:',
             placeholder: fallback,
         });
         const trimmed = value.trim();
@@ -101,40 +98,48 @@ export default class AccountLoginCommand extends BaseAccountCommand {
     }
     createAccountFromKey(privateKey) {
         try {
-            const account = privateKeyToAccount(privateKey);
-            return {
-                address: account.address,
-                privateKey: privateKey,
-            };
+            return this.accountService.createAccountFromKey(privateKey);
         }
         catch (error) {
-            this.logger.error({ err: error }, 'Invalid private key provided.');
-            this.error('Invalid private key provided.');
+            const message = error instanceof Error && error.message ? error.message : 'Invalid private key provided.';
+            this.logger.error({ err: error }, message);
+            this.error(message);
         }
     }
-    async createConfigIfMissing(configFile, displayName, providerUrl, account) {
-        const configPath = path.join(this.configFileManager.getConfigDir(), configFile);
-        if (existsSync(configPath)) {
-            return;
+    async updateConfigDisplayName(configFile, displayName) {
+        const result = await this.accountService.updateConfigDisplayName(configFile, displayName);
+        if (result.status === 'skipped') {
+            return configFile;
         }
-        await this.configFileManager.createConfig(configFile, displayName, providerUrl, account);
-        this.log(`Created configuration: ${displayName}`);
-    }
-    findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
-        const normalizedKey = privateKey.trim().toLowerCase();
-        const configs = this.configFileManager.getConfigsWithNames();
-        const matches = [];
-        for (const config of configs) {
-            const configData = this.configFileManager.getConfigData(config.file);
-            const storedKey = configData?.account?.privateKey?.toLowerCase();
-            const storedUrl = (configData?.providerUrl ?? PROVIDER_URL).trim();
-            const keyMatches = storedKey === normalizedKey;
-            const urlMatches = !matchProviderUrl || storedUrl === providerUrl;
-            if (keyMatches && urlMatches) {
-                matches.push(config);
-            }
+        if (result.status === 'updated') {
+            this.log(`Updated account name to "${displayName}"`);
+        }
+        else {
+            this.log(`Account name: "${displayName}"`);
         }
-        return matches;
+        return result.configFile;
+    }
+    async setCurrentAndAuth(configFile, authUrl) {
+        await this.accountService.setCurrentConfig(configFile);
+        await this.accountService.updateConfigAuthUrl(configFile, authUrl);
+    }
+    async applySelectionWithDisplayName(configFile, displayName, authUrl) {
+        const updatedFile = await this.updateConfigDisplayName(configFile, displayName);
+        await this.setCurrentAndAuth(updatedFile, authUrl);
+        return updatedFile;
+    }
+    async selectMatchedConfig(matches) {
+        if (matches.length === 1) {
+            return matches[0].file;
+        }
+        if (this.flags.yes) {
+            this.log(`Too many matched accounts: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
+            return matches[0].file;
+        }
+        return this.selectPrompt({
+            message: 'Multiple accounts found for this private key. Select one:',
+            options: matches.map((match) => ({ label: match.name, value: match.file })),
+        });
     }
     async getPrivateKeyOrGenerate() {
         const generatedKey = generatePrivateKey();
@@ -149,17 +154,17 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         const trimmed = value.trim();
         return trimmed || generatedKey;
     }
-    async resolveByName(name, privateKey, providerUrl) {
-        const configs = this.configFileManager.getConfigsWithNames();
+    async resolveByName(name, privateKey, swarmUrl, authUrl) {
+        const configs = await this.accountService.getConfigsWithNames();
         const normalized = name.toLowerCase();
         const existingByName = configs.find((config) => config.name.toLowerCase() === normalized || config.file.toLowerCase() === normalized);
         if (existingByName) {
-            await this.configFileManager.setCurrentConfig(existingByName.file);
+            await this.setCurrentAndAuth(existingByName.file, authUrl);
             return;
         }
         let shouldCreate = true;
         if (!this.flags.yes) {
-            shouldCreate = await this.confirmPrompt(`Configuration "${name}" not found. Create it?`, true);
+            shouldCreate = await this.confirmPrompt(`Account with "${name}" not found. Create it?`, true);
         }
         if (!shouldCreate) {
             this.shouldSkipLogin = true;
@@ -167,74 +172,125 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         }
         const resolvedKey = privateKey ?? (await this.getPrivateKeyOrGenerate());
         const account = this.createAccountFromKey(resolvedKey);
-        const configFile = getConfigNameFromCredentials(resolvedKey, providerUrl);
-        await this.createConfigIfMissing(configFile, name, providerUrl, account);
+        const configFile = getConfigName(name);
+        const { created, configFile: createdFile } = await this.accountService.createConfigIfMissing(configFile, name, swarmUrl, account, authUrl);
+        if (created) {
+            this.log(`Created account: ${name}`);
+        }
         let shouldSwitch = true;
         if (!this.flags.yes) {
-            shouldSwitch = await this.confirmPrompt(`Switch to configuration "${name}" now?`, true);
+            shouldSwitch = await this.confirmPrompt(`Switch to account "${name}" now?`, true);
         }
         if (!shouldSwitch) {
             this.shouldSkipLogin = true;
             return;
         }
-        await this.configFileManager.setCurrentConfig(configFile);
+        await this.setCurrentAndAuth(createdFile, authUrl);
     }
-    async resolveByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
-        const matches = this.findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl);
-        if (matches.length === 1) {
-            await this.configFileManager.setCurrentConfig(matches[0].file);
+    async loadConfigFromPath(configPath) {
+        try {
+            return await this.accountService.loadConfigFromPath(configPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`Invalid account file: ${message}`, { exit: 1 });
+        }
+    }
+    async resolveByPath(rawPath, name, authUrl) {
+        const sourcePath = preparePath(rawPath);
+        const config = await this.loadConfigFromPath(sourcePath);
+        const targetFile = this.accountService.resolveConfigFileName(sourcePath, config, name);
+        const desiredName = name?.trim();
+        const privateKey = config.account.privateKey;
+        const swarmUrl = (config.swarmUrl ?? SWARM_URL).trim();
+        const matches = await this.accountService.findConfigsByPrivateKey(privateKey, swarmUrl, true);
+        if (matches.length > 0) {
+            const selectedFile = await this.selectMatchedConfig(matches);
+            this.log('Account already exists. Nothing to import.');
+            await this.applySelectionWithDisplayName(selectedFile, desiredName, authUrl);
             return;
         }
-        if (matches.length > 1) {
-            if (this.flags.yes) {
-                this.log(`Too many matched configs: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
-                await this.configFileManager.setCurrentConfig(matches[0].file);
-                return;
+        if (await this.accountService.configExists(targetFile)) {
+            const existingConfig = await this.accountService.getConfigData(targetFile);
+            const existingKey = existingConfig?.account?.privateKey?.trim().toLowerCase();
+            const existingUrl = (existingConfig?.swarmUrl ?? SWARM_URL).trim();
+            const importedKey = privateKey.trim().toLowerCase();
+            if (!existingKey || existingKey !== importedKey || existingUrl !== swarmUrl) {
+                this.error(`Account file "${targetFile}" already exists with different credentials. Use a different name or remove the existing file before importing.`, { exit: 1 });
             }
-            const selected = await this.selectPrompt({
-                message: 'Multiple configurations found for this private key. Select one:',
-                options: matches.map((match) => ({ label: match.name, value: match.file })),
-            });
-            await this.configFileManager.setCurrentConfig(selected);
+            this.log(`Account already exists. Switching to ${name || targetFile}`);
+            await this.setCurrentAndAuth(targetFile, authUrl);
+            return;
+        }
+        try {
+            const importedFile = await this.accountService.importConfig(sourcePath, name);
+            await this.setCurrentAndAuth(importedFile, authUrl);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error), { exit: 1 });
+        }
+    }
+    async resolveByPrivateKey(privateKey, swarmUrl, matchSwarmUrl, name, authUrl) {
+        const matches = await this.accountService.findConfigsByPrivateKey(privateKey, swarmUrl, matchSwarmUrl);
+        const desiredName = name?.trim();
+        if (matches.length > 0) {
+            const selectedFile = await this.selectMatchedConfig(matches);
+            await this.applySelectionWithDisplayName(selectedFile, desiredName, authUrl);
             return;
         }
         let shouldCreate = true;
         if (!this.flags.yes) {
-            shouldCreate = await this.confirmPrompt('No configuration found for this private key. Create a new one?', true);
+            shouldCreate = await this.confirmPrompt('No accounts found for this private key. Create a new one?', true);
         }
         if (!shouldCreate) {
             this.shouldSkipLogin = true;
             return;
         }
         const account = this.createAccountFromKey(privateKey);
-        const suggestedName = this.flags.name?.trim() || account.address;
+        const suggestedName = desiredName || account.address;
         const displayName = this.flags.yes ? suggestedName : await this.askName(suggestedName);
-        const configFile = getConfigNameFromCredentials(privateKey, providerUrl);
-        await this.createConfigIfMissing(configFile, displayName, providerUrl, account);
+        const configFile = getConfigName(displayName);
+        const { created, configFile: createdFile } = await this.accountService.createConfigIfMissing(configFile, displayName, swarmUrl, account, authUrl);
+        if (created) {
+            this.log(`Created account: ${displayName}`);
+        }
         let shouldSwitch = true;
         if (!this.flags.yes) {
-            shouldSwitch = await this.confirmPrompt(`Switch to configuration "${displayName}" now?`, true);
+            shouldSwitch = await this.confirmPrompt(`Switch to account "${displayName}" now?`, true);
         }
         if (!shouldSwitch) {
             this.shouldSkipLogin = true;
             return;
         }
-        await this.configFileManager.setCurrentConfig(configFile);
+        await this.setCurrentAndAuth(createdFile, authUrl);
     }
     async resolveConfiguration() {
         const name = this.flags.name?.trim();
+        const configPath = this.flags.path?.trim();
+        if (configPath !== undefined && !configPath) {
+            this.error('Account path cannot be empty.', { exit: 1 });
+        }
         const privateKey = this.flags.privateKey?.trim();
         const url = this.flags.url?.trim();
         if (url !== undefined && !url) {
-            this.error('Provider URL cannot be empty.', { exit: 1 });
+            this.error('Swarm URL cannot be empty.', { exit: 1 });
         }
-        const providerUrl = (url || PROVIDER_URL).trim();
-        if (name) {
-            await this.resolveByName(name, privateKey, providerUrl);
+        const authUrl = this.flags.authUrl?.trim();
+        if (authUrl !== undefined && !authUrl) {
+            this.error('Auth URL cannot be empty.', { exit: 1 });
+        }
+        const swarmUrl = (url || SWARM_URL).trim();
+        if (configPath) {
+            await this.resolveByPath(configPath, name, authUrl);
             return;
         }
         if (privateKey) {
-            await this.resolveByPrivateKey(privateKey, providerUrl, Boolean(url));
+            await this.resolveByPrivateKey(privateKey, swarmUrl, Boolean(url), name, authUrl);
+            return;
+        }
+        if (name) {
+            await this.resolveByName(name, privateKey, swarmUrl, authUrl);
+            return;
         }
     }
     static maskPrivateKey(privateKey) {

package/dist/commands/account/switch.d.ts

@@ -6,6 +6,9 @@ export default class AccountSwitchCommand extends BaseAccountCommand<typeof Acco
     static examples: string[];
     protected configFileManager: ConfigFileManager;
     protected configManager: ConfigManager;
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
     init(): Promise<void>;
     run(): Promise<void>;
     private switchConfig;

package/dist/commands/account/switch.js

@@ -1,3 +1,4 @@
+import { Flags } from '@oclif/core';
 import { BaseAccountCommand } from './base.js';
 export default class AccountSwitchCommand extends BaseAccountCommand {
     static authenticate = false;
@@ -5,6 +6,12 @@ export default class AccountSwitchCommand extends BaseAccountCommand {
     static examples = ['<%= config.bin %> <%= command.id %>'];
     configFileManager;
     configManager;
+    static flags = {
+        name: Flags.string({
+            char: 'n',
+            description: 'Account name to switch',
+        }),
+    };
     async init() {
         await super.init();
         await this.container.initConfigFileManager().build();
@@ -12,28 +19,41 @@ export default class AccountSwitchCommand extends BaseAccountCommand {
         await this.container.initConfigManager().build();
     }
     async run() {
-        const configs = this.configFileManager.getConfigsWithNames();
+        const { name } = this.flags;
+        const configs = await this.configFileManager.getConfigsWithNames();
         const currentConfig = this.configFileManager.getCurrentConfigFile();
         if (configs.length === 0) {
             this.log('No accounts found');
-            this.log('Create a new account with: sp account login --privateKey "<PRIVATE_KEY>" --name "Account Name"');
+            this.log('Create a new account with: sp account login --privateKey "<PRIVATE_KEY>" --name "Account Name" or sp account login');
             return;
         }
-        const selected = await this.selectPrompt({
-            initialValue: currentConfig,
-            message: 'Select an account:',
-            options: configs.map((config) => ({
-                label: config.name ?? config.file,
-                value: config.file,
-            })),
-        });
+        let selected;
+        if (name) {
+            try {
+                const config = await this.configFileManager.getConfigWithName(name);
+                selected = config.file;
+            }
+            catch {
+                this.error(`Account with name ${name} not found`);
+            }
+        }
+        else {
+            selected = await this.selectPrompt({
+                initialValue: currentConfig,
+                message: 'Select an account:',
+                options: configs.map((config) => ({
+                    label: config.name ?? config.file,
+                    value: config.file,
+                })),
+            });
+        }
         const selectedConfig = configs.find((c) => c.file === selected);
         await this.switchConfig(selected, selectedConfig?.name || selected);
     }
     async switchConfig(configFile, displayName) {
         await this.configFileManager.setCurrentConfig(configFile);
         this.log(`Switched to account: ${displayName || configFile}`);
-        await this.initAccountContext({ enableAuth: false, enableCookies: true, rebuild: true });
+        await this.container.initConfigManager(true).build();
         this.configFileManager = this.container.configFileManager;
         this.configManager = this.container.configManager;
     }

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

@@ -0,0 +1,39 @@
+import type { Command } from '@oclif/core';
+import { type AssetCredentials, AssetService, AssetType, SourceType } from '../../services/asset.service.js';
+import { BaseCommand } from '../base.js';
+export type AssetCredentialsFlags = {
+    storjBucket?: string;
+    storjPath?: string;
+    storjToken?: string;
+    s3Bucket?: string;
+    s3Path?: string;
+    s3AccessKey?: string;
+    s3SecretKey?: string;
+    s3Region?: string;
+    s3Endpoint?: string;
+    dockerImage?: string;
+    dockerRegistry?: string;
+    dockerUsername?: string;
+    dockerPassword?: string;
+    githubRepo?: string;
+    githubToken?: string;
+    githubBranch?: string;
+    gdocsDocumentId?: string;
+    gdocsApiKey?: string;
+    gdocsServiceAccountJson?: string;
+};
+export declare abstract class BaseAssetCommand<T extends typeof Command> extends BaseCommand<T> {
+    static summary: string;
+    protected assetService: AssetService;
+    protected currentDir: string;
+    init(): Promise<void>;
+    protected parseCredentialsInput(raw: string, fieldName: string): Record<string, unknown>;
+    protected promptCredentials<T extends SourceType>(sourceType: T): Promise<AssetCredentials>;
+    protected promptOptionalText(message: string, secret?: boolean): Promise<string | undefined>;
+    protected promptRequiredText(message: string): Promise<string>;
+    protected parseSizeInput(raw: string): number | undefined;
+    protected getAllowedSourceTypes(type: AssetType): readonly SourceType[];
+    protected assertSourceTypeAllowed(type: AssetType, sourceType: SourceType): void;
+    protected hasCredentialsFlags(flags: AssetCredentialsFlags): boolean;
+    protected buildCredentialsFromFlags(sourceType: SourceType, flags: AssetCredentialsFlags): AssetCredentials;
+}