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

package/dist/commands/account/get-sppi.js

@@ -1,18 +1,14 @@
-import { formatEther } from 'viem';
+//import { formatEther } from 'viem';
 import { BaseAccountCommand } from './base.js';
 export default class AccountGetSppi extends BaseAccountCommand {
     static description = 'Get SPPI (Super Protocol incentive tokens) ';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     async run() {
-        await this.initAccountContext();
-        const { providerClient } = this.container;
-        const { data, error } = await providerClient.POST('/api/faucet/request-tokens');
-        if (error) {
-            this.error(`Getting SPPI failed. Reason: ${error.message}`);
-        }
-        const tokens = formatEther(BigInt(data.amount || '0'));
-        this.log('Tokens replenished');
-        this.log(`Current balance: ${tokens} SPPI`);
-        return { tokens };
+        this.error('Not implemented yet');
+        // await this.initAccountContext();
+        // const tokens = formatEther(BigInt('0'));
+        // this.log('Tokens replenished');
+        // this.log(`Current balance: ${tokens} SPPI`);
+        // return { tokens };
     }
 }

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

@@ -6,20 +6,8 @@ export declare class InfoCommand extends BaseAccountCommand<typeof InfoCommand>
     };
     init(): Promise<void>;
     run(): Promise<{
-        address: string;
+        address: string | undefined;
         balance: string;
-        storage: {
-            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;
-        };
         wallet: string;
     }>;
 }

package/dist/commands/account/info.js

@@ -1,7 +1,6 @@
 import { Flags } from '@oclif/core';
 import { formatEther } from 'viem';
-import { PROVIDER_URL } from '../../constants.js';
-import { StorageService } from '../../services/storage.service.js';
+import { SWARM_URL } from '../../constants.js';
 import { BaseAccountCommand } from './base.js';
 export class InfoCommand extends BaseAccountCommand {
     static description = 'Information about current authorized user';
@@ -17,54 +16,36 @@ export class InfoCommand extends BaseAccountCommand {
     }
     async run() {
         const { flags } = await this.parse(InfoCommand);
-        const { providerClient } = this.container;
-        const storageService = new StorageService(providerClient, this.logger);
-        const { data, error } = await providerClient.GET('/api/auth/me');
-        if (error) {
-            this.error(error.message);
+        const { accountManager, configFileManager } = this.container;
+        const current = configFileManager.getCurrentConfigFile();
+        let address;
+        try {
+            address = accountManager.getAddress();
         }
-        if (!data) {
-            this.error('Failed to retrieve account information');
-        }
-        const { data: wallet } = await providerClient.GET('/api/users/me/wallet');
-        if (!wallet) {
-            this.error('Failed to retrieve wallet information');
-        }
-        const storage = await storageService.getCurrentStorage();
-        const balance = formatEther(BigInt(wallet?.teeBalance || '0'));
-        this.log(`Login: ${data.address}`);
-        this.log(`Super Wallet: ${data.internalAddress}`);
+        catch { }
+        const walletAddress = 'N/A';
+        const balance = formatEther(0n);
+        this.log(`Login: ${address || 'N/A'}`);
+        this.log(`Super Wallet: ${walletAddress}`);
         this.log(`Balance: ${balance} SPPI`);
-        if (storage.isCentralized) {
-            this.log('Storage: Super cloud');
-        }
-        else {
-            this.log('Active storage:');
-            this.log(`  bucket: ${storage.bucket}`);
-            if (storage.prefix) {
-                this.log(`  prefix: ${storage.prefix}`);
-            }
-        }
         if (flags.detail) {
-            const { configFileManager } = this.container;
-            const current = configFileManager.getCurrentConfigFile();
             const configDir = configFileManager.getConfigDir();
             this.log('\n-----------------(DETAILS)-----------------------');
             if (current) {
-                const configs = configFileManager.getConfigsWithNames();
+                const configs = await configFileManager.getConfigsWithNames();
                 const currentConfig = configs.find((c) => c.file === current);
                 const displayName = currentConfig?.name || current;
-                const configData = configFileManager.getConfigData(current);
+                const configData = await configFileManager.getConfigData(current);
                 this.log(`Current account: ${displayName}`);
                 this.log(`Configuration file: ${current}`);
                 this.log(`Configuration directory: ${configDir}`);
                 if (configData) {
                     this.log('\nAccount details:');
-                    if (configData.providerUrl) {
-                        this.log(`  Provider URL: ${configData.providerUrl}`);
+                    if (configData.swarmUrl) {
+                        this.log(`  Swarm URL: ${configData.swarmUrl}`);
                     }
                     else {
-                        this.log(`  Provider URL: ${PROVIDER_URL} (using default)`);
+                        this.log(`  Swarm URL: ${SWARM_URL} (using default)`);
                     }
                     if (configData.auth?.accessKey) {
                         this.log('  Authorization: Configured');
@@ -72,8 +53,8 @@ export class InfoCommand extends BaseAccountCommand {
                     else {
                         this.log('  Authorization: Unauthorized');
                     }
-                    if (configData.account?.address) {
-                        this.log(`  Account: ${configData.account.address}`);
+                    if (address) {
+                        this.log(`  Account: ${address}`);
                     }
                     else {
                         this.log('  Account: Not configured');
@@ -87,10 +68,9 @@ export class InfoCommand extends BaseAccountCommand {
             }
         }
         return {
-            address: data.address,
+            address,
             balance,
-            storage,
-            wallet: data.internalAddress,
+            wallet: walletAddress,
         };
     }
 }

package/dist/commands/account/list.js

@@ -1,5 +1,5 @@
 import { printTable } from 'console-table-printer';
-import { PROVIDER_URL } from '../../constants.js';
+import { SWARM_URL } from '../../constants.js';
 import { BaseCommand } from '../base.js';
 export default class AccountListCommand extends BaseCommand {
     static authenticate = false;
@@ -13,23 +13,23 @@ export default class AccountListCommand extends BaseCommand {
         await this.container.initConfigManager().build();
     }
     async run() {
-        const configs = this.configFileManager.getConfigsWithNames();
+        const configs = await this.configFileManager.getConfigsWithNames();
         const current = 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>" --url "<PROVIDER_URL>" --name "Account Name"');
+            this.log('Create a new account with: sp account login --privateKey "<PRIVATE_KEY>" --url "<SWARM_URL>" --name "Account Name"');
             return;
         }
         const rows = [];
         for (const config of configs) {
             const marker = config.file === current ? '* ' : '  ';
-            const configData = this.configFileManager.getConfigData(config.file);
+            const configData = await this.configFileManager.getConfigData(config.file);
             const row = {
                 account: configData?.account?.address ?? '[not found in config file]',
                 current: marker,
                 file: config.file,
                 name: config.name,
-                url: configData?.providerUrl ?? PROVIDER_URL,
+                url: configData?.swarmUrl ?? SWARM_URL,
             };
             rows.push(row);
         }
@@ -38,7 +38,7 @@ export default class AccountListCommand extends BaseCommand {
                 { name: 'current', title: 'Current' },
                 { name: 'name', title: 'Config name' },
                 { name: 'account', title: 'Account' },
-                { name: 'url', title: 'Provider Url' },
+                { name: 'url', title: 'Swarm Url' },
                 { name: 'file', title: 'Configuration File' },
             ],
             title: 'Available Accounts',

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

@@ -2,6 +2,7 @@ import { BaseAccountCommand } from './base.js';
 export default class AccountLoginCommand extends BaseAccountCommand<typeof AccountLoginCommand> {
     static aliases: string[];
     static authenticate: boolean;
+    static summary: string;
     static description: string;
     static examples: string[];
     static flags: {
@@ -9,9 +10,10 @@ export default class AccountLoginCommand extends BaseAccountCommand<typeof Accou
         privateKey: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         path: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         url: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        authUrl: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    private configFileManager;
+    private accountService;
     private shouldSkipLogin;
     private inputPrompt;
     private checkStorage;
@@ -26,14 +28,13 @@ export default class AccountLoginCommand extends BaseAccountCommand<typeof Accou
     private askName;
     private confirmPrompt;
     private createAccountFromKey;
-    private createConfigIfMissing;
     private updateConfigDisplayName;
-    private findConfigsByPrivateKey;
+    private setCurrentAndAuth;
+    private applySelectionWithDisplayName;
+    private selectMatchedConfig;
     private getPrivateKeyOrGenerate;
     private resolveByName;
-    private assertConfigHasAccount;
     private loadConfigFromPath;
-    private resolveConfigFileName;
     private resolveByPath;
     private resolveByPrivateKey;
     private resolveConfiguration;

package/dist/commands/account/login.js

@@ -1,18 +1,15 @@
-import { existsSync } from 'node:fs';
-import path from 'node:path';
 import { Flags } from '@oclif/core';
-import { Value } from 'typebox/value';
-import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
-import { cliConfigSchema } from '../../config/config.schema.js';
-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 { getConfigName, getConfigNameFromCredentials, preparePath, readJsonFile, } 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 %>
@@ -29,7 +26,11 @@ export default class AccountLoginCommand extends BaseAccountCommand {
             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({
@@ -38,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();
@@ -106,52 +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)) {
-            await this.configFileManager.updateConfigName(configFile, displayName);
-            return;
-        }
-        await this.configFileManager.createConfig(configFile, displayName, providerUrl, account);
-        this.log(`Created account: ${displayName}`);
-    }
     async updateConfigDisplayName(configFile, displayName) {
-        if (!displayName) {
-            return;
+        const result = await this.accountService.updateConfigDisplayName(configFile, displayName);
+        if (result.status === 'skipped') {
+            return configFile;
         }
-        const updated = await this.configFileManager.updateConfigName(configFile, displayName);
-        if (updated) {
+        if (result.status === 'updated') {
             this.log(`Updated account name to "${displayName}"`);
-            return;
         }
-        this.log(`Account name: "${displayName}"`);
+        else {
+            this.log(`Account name: "${displayName}"`);
+        }
+        return result.configFile;
     }
-    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);
-            }
+    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 matches;
+        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();
@@ -166,12 +154,12 @@ 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;
@@ -184,8 +172,11 @@ 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 account "${name}" now?`, true);
@@ -194,104 +185,57 @@ export default class AccountLoginCommand extends BaseAccountCommand {
             this.shouldSkipLogin = true;
             return;
         }
-        await this.configFileManager.setCurrentConfig(configFile);
-    }
-    assertConfigHasAccount(config) {
-        if (!config.account?.privateKey) {
-            throw new Error('Account private key is required for import.');
-        }
+        await this.setCurrentAndAuth(createdFile, authUrl);
     }
     async loadConfigFromPath(configPath) {
         try {
-            const config = await readJsonFile({ path: configPath });
-            if (!Value.Check(cliConfigSchema, config)) {
-                throw new Error("Account doesn't match required schema");
-            }
-            this.assertConfigHasAccount(config);
-            return config;
+            return await this.accountService.loadConfigFromPath(configPath);
         }
         catch (error) {
-            this.error(`Invalid account file: ${error instanceof Error ? error.message : String(error)}`, { exit: 1 });
-        }
-    }
-    resolveConfigFileName(configPath, config, name) {
-        if (name) {
-            return getConfigName(name);
-        }
-        if (config.name) {
-            return getConfigName(config.name);
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`Invalid account file: ${message}`, { exit: 1 });
         }
-        const baseName = path.basename(configPath, path.extname(configPath));
-        return getConfigName(baseName);
     }
-    async resolveByPath(rawPath, name) {
+    async resolveByPath(rawPath, name, authUrl) {
         const sourcePath = preparePath(rawPath);
         const config = await this.loadConfigFromPath(sourcePath);
-        const targetFile = this.resolveConfigFileName(sourcePath, config, name);
-        const targetPath = path.join(this.configFileManager.getConfigDir(), targetFile);
+        const targetFile = this.accountService.resolveConfigFileName(sourcePath, config, name);
         const desiredName = name?.trim();
         const privateKey = config.account.privateKey;
-        const providerUrl = (config.providerUrl ?? PROVIDER_URL).trim();
-        const matches = this.findConfigsByPrivateKey(privateKey, providerUrl, true);
+        const swarmUrl = (config.swarmUrl ?? SWARM_URL).trim();
+        const matches = await this.accountService.findConfigsByPrivateKey(privateKey, swarmUrl, true);
         if (matches.length > 0) {
-            let selectedFile = matches[0].file;
-            if (matches.length > 1) {
-                if (this.flags.yes) {
-                    this.log(`Too many matched accounts: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
-                }
-                else {
-                    selectedFile = await this.selectPrompt({
-                        message: 'Multiple accounts found for this private key. Select one:',
-                        options: matches.map((match) => ({ label: match.name, value: match.file })),
-                    });
-                }
-            }
+            const selectedFile = await this.selectMatchedConfig(matches);
             this.log('Account already exists. Nothing to import.');
-            await this.updateConfigDisplayName(selectedFile, desiredName);
-            await this.configFileManager.setCurrentConfig(selectedFile);
+            await this.applySelectionWithDisplayName(selectedFile, desiredName, authUrl);
             return;
         }
-        if (existsSync(targetPath)) {
-            const existingConfig = this.configFileManager.getConfigData(targetFile);
+        if (await this.accountService.configExists(targetFile)) {
+            const existingConfig = await this.accountService.getConfigData(targetFile);
             const existingKey = existingConfig?.account?.privateKey?.trim().toLowerCase();
-            const existingUrl = (existingConfig?.providerUrl ?? PROVIDER_URL).trim();
+            const existingUrl = (existingConfig?.swarmUrl ?? SWARM_URL).trim();
             const importedKey = privateKey.trim().toLowerCase();
-            if (!existingKey || existingKey !== importedKey || existingUrl !== providerUrl) {
+            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 });
             }
             this.log(`Account already exists. Switching to ${name || targetFile}`);
-            await this.configFileManager.setCurrentConfig(targetFile);
+            await this.setCurrentAndAuth(targetFile, authUrl);
             return;
         }
         try {
-            const importedFile = await this.configFileManager.importConfig(sourcePath, name);
-            await this.configFileManager.setCurrentConfig(importedFile);
+            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, providerUrl, matchProviderUrl, name) {
-        const matches = this.findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl);
+    async resolveByPrivateKey(privateKey, swarmUrl, matchSwarmUrl, name, authUrl) {
+        const matches = await this.accountService.findConfigsByPrivateKey(privateKey, swarmUrl, matchSwarmUrl);
         const desiredName = name?.trim();
-        if (matches.length === 1) {
-            await this.updateConfigDisplayName(matches[0].file, desiredName);
-            await this.configFileManager.setCurrentConfig(matches[0].file);
-            return;
-        }
-        if (matches.length > 1) {
-            if (this.flags.yes) {
-                this.log(`Too many matched accounts: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
-                await this.updateConfigDisplayName(matches[0].file, desiredName);
-                await this.configFileManager.setCurrentConfig(matches[0].file);
-                return;
-            }
-            const selected = await this.selectPrompt({
-                message: 'Multiple accounts found for this private key. Select one:',
-                options: matches.map((match) => ({ label: match.name, value: match.file })),
-            });
-            await this.updateConfigDisplayName(selected, desiredName);
-            await this.configFileManager.setCurrentConfig(selected);
+        if (matches.length > 0) {
+            const selectedFile = await this.selectMatchedConfig(matches);
+            await this.applySelectionWithDisplayName(selectedFile, desiredName, authUrl);
             return;
         }
         let shouldCreate = true;
@@ -305,8 +249,11 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         const account = this.createAccountFromKey(privateKey);
         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 account "${displayName}" now?`, true);
@@ -315,7 +262,7 @@ export default class AccountLoginCommand extends BaseAccountCommand {
             this.shouldSkipLogin = true;
             return;
         }
-        await this.configFileManager.setCurrentConfig(configFile);
+        await this.setCurrentAndAuth(createdFile, authUrl);
     }
     async resolveConfiguration() {
         const name = this.flags.name?.trim();
@@ -326,19 +273,23 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         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 authUrl = this.flags.authUrl?.trim();
+        if (authUrl !== undefined && !authUrl) {
+            this.error('Auth URL cannot be empty.', { exit: 1 });
         }
-        const providerUrl = (url || PROVIDER_URL).trim();
+        const swarmUrl = (url || SWARM_URL).trim();
         if (configPath) {
-            await this.resolveByPath(configPath, name);
+            await this.resolveByPath(configPath, name, authUrl);
             return;
         }
         if (privateKey) {
-            await this.resolveByPrivateKey(privateKey, providerUrl, Boolean(url), name);
+            await this.resolveByPrivateKey(privateKey, swarmUrl, Boolean(url), name, authUrl);
             return;
         }
         if (name) {
-            await this.resolveByName(name, privateKey, providerUrl);
+            await this.resolveByName(name, privateKey, swarmUrl, authUrl);
             return;
         }
     }

package/dist/commands/account/switch.js

@@ -20,7 +20,7 @@ export default class AccountSwitchCommand extends BaseAccountCommand {
     }
     async run() {
         const { name } = this.flags;
-        const configs = this.configFileManager.getConfigsWithNames();
+        const configs = await this.configFileManager.getConfigsWithNames();
         const currentConfig = this.configFileManager.getCurrentConfigFile();
         if (configs.length === 0) {
             this.log('No accounts found');
@@ -30,7 +30,7 @@ export default class AccountSwitchCommand extends BaseAccountCommand {
         let selected;
         if (name) {
             try {
-                const config = this.configFileManager.getConfigWithName(name);
+                const config = await this.configFileManager.getConfigWithName(name);
                 selected = config.file;
             }
             catch {