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

package/dist/managers/config-file-manager.js

@@ -1,9 +1,9 @@
-import * as fs from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { Value } from 'typebox/value';
 import { cliConfigSchema } from '../config/config.schema.js';
-import { DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME, DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, } from '../constants.js';
-import { getConfigName } from '../utils/helper.js';
+import { DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME, DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, SWARM_URL, } from '../constants.js';
+import { getConfigName, getConfigNameFromCredentials } from '../utils/helper.js';
 export class ConfigFileManager {
     logger;
     static CONFIG_FILE = 'config.json';
@@ -22,24 +22,29 @@ export class ConfigFileManager {
         this.configsDir = path.join(this.configDir, ConfigFileManager.CONFIGS_DIR);
         this.runtimeConfigFile = options.runtimeConfigFile;
     }
-    async createConfig(configFileName, name, url, account) {
-        const configPath = path.join(this.configsDir, configFileName);
-        if (fs.existsSync(configPath)) {
-            throw new Error(`Account file already exists: ${configFileName}`);
+    async createConfig(configFileName, name, url, account, authUrl) {
+        const normalizedName = name?.trim();
+        const resolvedFileName = normalizedName ? getConfigName(normalizedName) : configFileName;
+        const configPath = path.join(this.configsDir, resolvedFileName);
+        if (await this.pathExists(configPath)) {
+            throw new Error(`Account file already exists: ${resolvedFileName}`);
+        }
+        const config = {};
+        if (normalizedName) {
+            config.name = normalizedName;
         }
-        const config = { name };
         if (url) {
-            config.providerUrl = url;
+            config.swarmUrl = url;
         }
         if (account) {
             config.account = account;
         }
-        fs.writeFileSync(configPath, JSON.stringify(config, undefined, 2), {
-            encoding: 'utf8',
-            flag: 'w',
-            mode: FILE_ACCESS_PERMS,
-        });
-        this.logger.info({ configFileName, name, url }, 'Created new configuration');
+        if (authUrl) {
+            config.authUrl = authUrl;
+        }
+        await this.writeJsonFile(configPath, config);
+        this.logger.info({ configFileName: resolvedFileName, name: normalizedName, url }, 'Created new configuration');
+        return resolvedFileName;
     }
     async updateConfigName(configFileName, name) {
         const configPath = path.join(this.configsDir, configFileName);
@@ -47,41 +52,72 @@ export class ConfigFileManager {
         if (!normalizedName) {
             throw new Error('Configuration name cannot be empty');
         }
-        if (!fs.existsSync(configPath)) {
+        if (!(await this.pathExists(configPath))) {
             throw new Error(`Account file not found: ${configFileName}`);
         }
-        let config;
-        try {
-            const raw = fs.readFileSync(configPath, 'utf8');
-            config = JSON.parse(raw);
+        const config = await this.readJsonFileOrThrow(configPath, { configFileName }, 'Failed to read config data', `Failed to read configuration: ${configFileName}`);
+        const targetFileName = getConfigName(normalizedName);
+        const nameChanged = config.name !== normalizedName;
+        const fileChanged = targetFileName !== configFileName;
+        if (!nameChanged && !fileChanged) {
+            return { updated: false, fileName: configFileName };
+        }
+        if (fileChanged) {
+            const targetPath = path.join(this.configsDir, targetFileName);
+            if (await this.pathExists(targetPath)) {
+                throw new Error(`Account file already exists: ${targetFileName}`);
+            }
         }
-        catch (error) {
-            this.logger.warn({ configFileName, err: error }, 'Failed to read config data');
-            throw new Error(`Failed to read configuration: ${configFileName}`);
+        config.name = normalizedName;
+        if (fileChanged) {
+            const targetPath = path.join(this.configsDir, targetFileName);
+            await this.writeJsonFile(targetPath, config);
+            await fs.unlink(configPath);
+            if (this.configs.currentConfig === configFileName) {
+                this.configs.currentConfig = targetFileName;
+                await this.save();
+            }
         }
-        if (config.name === normalizedName) {
+        else {
+            await this.writeJsonFile(configPath, config);
+        }
+        this.logger.info({ configFileName, renamedTo: fileChanged ? targetFileName : undefined, name: normalizedName }, 'Updated configuration name');
+        return { updated: nameChanged, fileName: fileChanged ? targetFileName : configFileName };
+    }
+    async updateConfigAuthUrl(configFileName, authUrl) {
+        const configPath = path.join(this.configsDir, configFileName);
+        const normalizedUrl = authUrl.trim();
+        if (!normalizedUrl) {
+            throw new Error('Auth URL cannot be empty');
+        }
+        if (!(await this.pathExists(configPath))) {
+            throw new Error(`Account file not found: ${configFileName}`);
+        }
+        const config = await this.readJsonFileOrThrow(configPath, { configFileName }, 'Failed to read config data', `Failed to read configuration: ${configFileName}`);
+        if (config.authUrl === normalizedUrl) {
             return false;
         }
-        config.name = normalizedName;
-        fs.writeFileSync(configPath, JSON.stringify(config, undefined, 2), {
-            encoding: 'utf8',
-            flag: 'w',
-            mode: FILE_ACCESS_PERMS,
-        });
-        this.logger.info({ configFileName, name: normalizedName }, 'Updated configuration name');
+        config.authUrl = normalizedUrl;
+        await this.writeJsonFile(configPath, config);
+        this.logger.info({ configFileName, authUrl: normalizedUrl }, 'Updated auth URL');
         return true;
     }
     async deleteConfig(configName) {
         const configPath = path.join(this.configsDir, configName);
-        if (!fs.existsSync(configPath)) {
+        if (!(await this.pathExists(configPath))) {
             throw new Error(`Account file not found: ${configName}`);
         }
-        await this.removeConfig(configName);
-        fs.unlinkSync(configPath);
+        if (this.configs.currentConfig === configName) {
+            const configs = await this.listConfigFiles();
+            const remainingConfigs = configs.filter((c) => c !== configName);
+            this.configs.currentConfig = remainingConfigs.length > 0 ? remainingConfigs[0] : undefined;
+            await this.save();
+        }
+        await fs.unlink(configPath);
         this.logger.info({ configName }, 'Deleted configuration file');
     }
     async deleteConfigByName(name) {
-        const configs = this.getConfigsWithNames();
+        const configs = await this.getConfigsWithNames();
         if (configs.length === 0) {
             throw new Error('No configurations found');
         }
@@ -106,13 +142,13 @@ export class ConfigFileManager {
             this.logger.info('Create a new account with: sp account login --name "Account Name" or sp account login');
         }
     }
-    getConfigData(configName) {
+    async getConfigData(configName) {
         const configPath = path.join(this.configsDir, configName);
-        if (!fs.existsSync(configPath)) {
+        if (!(await this.pathExists(configPath))) {
             return undefined;
         }
         try {
-            const raw = fs.readFileSync(configPath, 'utf8');
+            const raw = await fs.readFile(configPath, 'utf8');
             return JSON.parse(raw);
         }
         catch (error) {
@@ -123,44 +159,49 @@ export class ConfigFileManager {
     getConfigDir() {
         return this.configsDir;
     }
-    getConfigs() {
-        if (!fs.existsSync(this.configsDir)) {
-            return [];
+    async configExists(configName) {
+        return this.pathExists(path.join(this.configsDir, configName));
+    }
+    async listConfigFiles() {
+        try {
+            const files = await fs.readdir(this.configsDir);
+            return files.filter((file) => file.endsWith('.json') || file.endsWith('.config.json'));
         }
-        return fs.readdirSync(this.configsDir).filter((file) => file.endsWith('.config.json'));
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    getConfigBaseName(file) {
+        if (file.endsWith('.config.json')) {
+            return file.slice(0, -'.config.json'.length);
+        }
+        return path.basename(file, path.extname(file));
     }
-    getConfigWithName(name) {
-        const configs = this.getConfigsWithNames();
-        const config = configs.filter((config) => config.name === name || config.file === name).at(0);
+    async getConfigWithName(name) {
+        const configs = await this.getConfigsWithNames();
+        const config = configs.find((config) => config.name === name ||
+            config.file === name ||
+            this.getConfigBaseName(config.file) === name);
         if (!config) {
             throw new Error(`Account with name ${name} not found`);
         }
         return config;
     }
-    getConfigsWithNames() {
-        if (!fs.existsSync(this.configsDir)) {
-            return [];
-        }
-        const configFiles = fs
-            .readdirSync(this.configsDir)
-            .filter((file) => file.endsWith('.config.json'));
-        return configFiles.map((configFile) => {
+    async getConfigsWithNames() {
+        const configFiles = await this.listConfigFiles();
+        return Promise.all(configFiles.map(async (configFile) => {
             const configPath = path.join(this.configsDir, configFile);
-            let name = configFile;
-            try {
-                if (fs.existsSync(configPath)) {
-                    const raw = fs.readFileSync(configPath, 'utf8');
-                    const config = JSON.parse(raw);
-                    if (config.name) {
-                        name = config.name;
-                    }
-                }
-            }
-            catch (error) {
-                this.logger.warn({ configFile, err: error }, 'Failed to read config name');
+            let name = this.getConfigBaseName(configFile);
+            const config = await this.tryReadJsonFile(configPath, { configFile }, 'Failed to read config name');
+            const normalizedName = config?.name?.trim();
+            if (normalizedName) {
+                name = normalizedName;
             }
             return { file: configFile, name };
-        });
+        }));
     }
     getCurrentConfigFile() {
         if (this.runtimeConfigFile) {
@@ -173,14 +214,18 @@ export class ConfigFileManager {
             return this.runtimeConfigFile;
         }
         if (!this.configs.currentConfig) {
+            let defaultConfigFile = DEFAULT_USER_CONFIG_FILE;
             try {
-                await this.createConfig(DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME);
+                defaultConfigFile = await this.createConfig(DEFAULT_USER_CONFIG_FILE, DEFAULT_USER_CONFIG_NAME);
             }
-            catch {
-                //
+            catch (error) {
+                if (!this.isAlreadyExistsError(error)) {
+                    this.logger.error({ err: error }, 'Failed to create default config');
+                    throw error;
+                }
             }
             try {
-                await this.setCurrentConfig(DEFAULT_USER_CONFIG_FILE);
+                await this.setCurrentConfig(defaultConfigFile);
             }
             catch (error) {
                 this.logger.error({ err: error }, 'Failed to set default config');
@@ -190,12 +235,12 @@ export class ConfigFileManager {
         return path.join(this.configsDir, this.configs.currentConfig || DEFAULT_USER_CONFIG_FILE);
     }
     async importConfig(sourcePath, targetName) {
-        if (!fs.existsSync(sourcePath)) {
+        if (!(await this.pathExists(sourcePath))) {
             throw new Error(`Source file not found: ${sourcePath}`);
         }
         let sourceConfig;
         try {
-            const raw = fs.readFileSync(sourcePath, 'utf8');
+            const raw = await fs.readFile(sourcePath, 'utf8');
             sourceConfig = JSON.parse(raw);
             if (!Value.Check(cliConfigSchema, sourceConfig)) {
                 throw new Error("Configuration doesn't match required schema");
@@ -204,23 +249,15 @@ export class ConfigFileManager {
         catch (error) {
             throw new Error(`Invalid configuration file: ${error instanceof Error ? error.message : String(error)}`);
         }
-        let targetFileName;
-        if (targetName) {
-            targetFileName = getConfigName(targetName);
-        }
-        else if (sourceConfig.name) {
-            targetFileName = getConfigName(sourceConfig.name);
-        }
-        else {
-            const basename = path.basename(sourcePath, path.extname(sourcePath));
-            targetFileName = getConfigName(basename);
-        }
+        const targetFileName = targetName
+            ? getConfigName(targetName)
+            : this.resolveConfigFileName(sourceConfig, path.basename(sourcePath, path.extname(sourcePath)));
         const targetPath = path.join(this.configsDir, targetFileName);
-        if (fs.existsSync(targetPath)) {
+        if (await this.pathExists(targetPath)) {
             throw new Error(`Configuration file already exists: ${targetFileName}`);
         }
-        fs.copyFileSync(sourcePath, targetPath);
-        fs.chmodSync(targetPath, FILE_ACCESS_PERMS);
+        await fs.copyFile(sourcePath, targetPath);
+        await fs.chmod(targetPath, FILE_ACCESS_PERMS);
         this.logger.info({ sourcePath, targetFileName }, 'Imported configuration');
         return targetFileName;
     }
@@ -229,20 +266,13 @@ export class ConfigFileManager {
             this.logger.debug({ runtimeConfigFile: this.runtimeConfigFile }, 'Runtime config provided, skipping config file initialization');
             return;
         }
-        this.ensureDirectories();
+        await this.ensureDirectories();
         await this.load();
-    }
-    async removeConfig(configName) {
-        if (this.configs.currentConfig === configName) {
-            const configs = this.getConfigs();
-            const remainingConfigs = configs.filter((c) => c !== configName);
-            this.configs.currentConfig = remainingConfigs.length > 0 ? remainingConfigs[0] : undefined;
-            await this.save();
-        }
+        await this.normalizeConfigFiles();
     }
     async setCurrentConfig(configName) {
         const configPath = path.join(this.configsDir, configName);
-        if (!fs.existsSync(configPath)) {
+        if (!(await this.pathExists(configPath))) {
             throw new Error(`Configuration file not found: ${configName}`);
         }
         this.configs.currentConfig = configName;
@@ -251,47 +281,142 @@ export class ConfigFileManager {
     setRuntimeConfigFile(runtimeConfigFile) {
         this.runtimeConfigFile = runtimeConfigFile;
     }
-    ensureDirectories() {
-        if (!fs.existsSync(this.configDir)) {
-            fs.mkdirSync(this.configDir, {
-                mode: DIR_ACCESS_PERMS,
-                recursive: true,
-            });
-        }
-        if (!fs.existsSync(this.configsDir)) {
-            fs.mkdirSync(this.configsDir, {
-                mode: DIR_ACCESS_PERMS,
-                recursive: true,
-            });
+    async ensureDirectories() {
+        await fs.mkdir(this.configDir, {
+            mode: DIR_ACCESS_PERMS,
+            recursive: true,
+        });
+        await fs.mkdir(this.configsDir, {
+            mode: DIR_ACCESS_PERMS,
+            recursive: true,
+        });
+    }
+    async normalizeConfigFiles() {
+        const configFiles = await this.listConfigFiles();
+        if (configFiles.length === 0) {
+            return;
+        }
+        let updatedCurrent = false;
+        for (const configFile of configFiles) {
+            const configPath = path.join(this.configsDir, configFile);
+            const config = await this.tryReadJsonFile(configPath, { configFile }, 'Failed to read config for normalization');
+            if (!config) {
+                continue;
+            }
+            const desiredFileName = this.resolveConfigFileName(config, this.getConfigBaseName(configFile));
+            if (desiredFileName === configFile) {
+                continue;
+            }
+            const targetPath = path.join(this.configsDir, desiredFileName);
+            if (await this.pathExists(targetPath)) {
+                this.logger.warn({ configFile, desiredFileName }, 'Config file name collision; skipping rename');
+                continue;
+            }
+            await fs.rename(configPath, targetPath);
+            if (this.configs.currentConfig === configFile) {
+                this.configs.currentConfig = desiredFileName;
+                updatedCurrent = true;
+            }
+            this.logger.info({ from: configFile, to: desiredFileName }, 'Renamed configuration file');
+        }
+        if (updatedCurrent) {
+            await this.save();
         }
     }
     async load() {
         try {
-            if (fs.existsSync(this.configFilePath)) {
-                const raw = fs.readFileSync(this.configFilePath, 'utf8');
-                this.configs = JSON.parse(raw);
-                this.logger.debug({ configs: this.configs }, 'Configs loaded');
+            const raw = await fs.readFile(this.configFilePath, 'utf8');
+            this.configs = JSON.parse(raw);
+            this.logger.debug({ configs: this.configs }, 'Configs loaded');
+        }
+        catch (error) {
+            if (this.isNotFoundError(error)) {
+                this.logger.debug('Config manager file not found, using defaults');
+                await this.save();
             }
             else {
-                this.logger.debug('Config manager file not found, using defaults');
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const backupPath = `${this.configFilePath}.corrupt-${timestamp}`;
+                this.logger.warn({ err: error, backupPath }, 'Config manager file appears corrupted; backing up and recreating');
+                try {
+                    await fs.rename(this.configFilePath, backupPath);
+                }
+                catch (backupError) {
+                    this.logger.error({ err: backupError, path: this.configFilePath, backupPath }, 'Failed to back up corrupted config manager file');
+                    throw backupError;
+                }
+                this.configs = {
+                    currentConfig: undefined,
+                };
                 await this.save();
             }
         }
-        catch (error) {
-            this.logger.error({ err: error }, 'Failed to load config manager file, using defaults');
-            this.configs = {
-                currentConfig: undefined,
-            };
-            await this.save();
-        }
     }
     async save() {
-        this.ensureDirectories();
+        await this.ensureDirectories();
         this.logger.debug({ configs: this.configs, path: this.configFilePath }, 'Saving config manager file');
-        fs.writeFileSync(this.configFilePath, JSON.stringify(this.configs, undefined, 2), {
+        await this.writeJsonFile(this.configFilePath, this.configs);
+    }
+    async pathExists(targetPath) {
+        try {
+            await fs.access(targetPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readJsonFileOrThrow(filePath, context, warnMessage, errorMessage) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            this.logger.warn({ ...context, err: error }, warnMessage);
+            throw new Error(errorMessage);
+        }
+    }
+    async tryReadJsonFile(filePath, context, warnMessage) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            this.logger.warn({ ...context, err: error }, warnMessage);
+            return undefined;
+        }
+    }
+    async writeJsonFile(filePath, data) {
+        await fs.writeFile(filePath, JSON.stringify(data, undefined, 2), {
             encoding: 'utf8',
             flag: 'w',
             mode: FILE_ACCESS_PERMS,
         });
     }
+    resolveConfigFileName(config, fallbackName) {
+        const normalizedName = config.name?.trim();
+        if (normalizedName) {
+            return getConfigName(normalizedName);
+        }
+        if (config.account?.privateKey) {
+            const swarmUrl = (config.swarmUrl ?? SWARM_URL).trim();
+            return getConfigNameFromCredentials(config.account.privateKey, swarmUrl);
+        }
+        return getConfigName(fallbackName);
+    }
+    isNotFoundError(error) {
+        return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT');
+    }
+    isAlreadyExistsError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        if ('code' in error && error.code === 'EEXIST') {
+            return true;
+        }
+        if (error instanceof Error) {
+            return /already exists/i.test(error.message);
+        }
+        return false;
+    }
 }

package/dist/managers/config-manager.d.ts

@@ -7,18 +7,18 @@ export declare class ConfigManager implements IConfigManager {
     private config;
     private readonly configDir;
     constructor(configFile: string, logger: pino.BaseLogger);
-    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
+    get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): undefined | V;
     private getConfig;
-    getCookies(): Promise<unknown>;
-    getCredentials(): Promise<{
-        accessKey: string;
-    } | undefined>;
+    getAuthUrl(): string;
+    getSwarmUrl(): string;
     init(): Promise<void>;
     load(): Promise<CliConfig>;
     private makeBackup;
     save(): Promise<void>;
     set<K extends keyof CliConfig, V extends CliConfig[K]>(key: K, value: V): Promise<void>;
-    setCookies(cookies: unknown): Promise<void>;
+    getCredentials(): {
+        accessKey: string;
+    } | undefined;
     setCredentials(auth: Auth): Promise<void>;
     private getConfigPath;
     private hasConfig;

package/dist/managers/config-manager.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import path from 'node:path';
 import { ux } from '@oclif/core';
-import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS } from '../constants.js';
+import { DIR_ACCESS_PERMS, FILE_ACCESS_PERMS, SWARM_URL } from '../constants.js';
 import { ConfigurationNotFoundError } from '../errors.js';
 export class ConfigManager {
     configFile;
@@ -13,7 +13,7 @@ export class ConfigManager {
         this.logger = logger;
         this.configDir = path.dirname(configFile);
     }
-    async get(key) {
+    get(key) {
         return this.config[key];
     }
     getConfig() {
@@ -24,11 +24,11 @@ export class ConfigManager {
         const raw = fs.readFileSync(configPath, 'utf8');
         return JSON.parse(raw);
     }
-    getCookies() {
-        return this.get('cookies');
+    getAuthUrl() {
+        return this.config.authUrl || this.getSwarmUrl();
     }
-    getCredentials() {
-        return this.get('auth');
+    getSwarmUrl() {
+        return this.config.swarmUrl || SWARM_URL;
     }
     async init() {
         try {
@@ -78,8 +78,8 @@ export class ConfigManager {
         this.logger.debug({ key }, 'Saving parameters to file');
         await this.save();
     }
-    async setCookies(cookies) {
-        await this.set('cookies', cookies);
+    getCredentials() {
+        return this.get('auth');
     }
     async setCredentials(auth) {
         await this.set('auth', auth);

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

@@ -0,0 +1,42 @@
+import { type Account, type CliConfig } from '../config/config.schema.js';
+import type { ConfigFileManager } from '../managers/index.js';
+export type CliConfigWithAccount = CliConfig & {
+    account: Account;
+};
+export declare class AccountServiceError extends Error {
+}
+export declare class InvalidPrivateKeyError extends AccountServiceError {
+}
+export declare class InvalidAccountConfigError extends AccountServiceError {
+}
+export type DisplayNameUpdateStatus = 'updated' | 'unchanged' | 'skipped';
+export declare class AccountService {
+    private readonly configFileManager;
+    constructor(configFileManager: ConfigFileManager);
+    createAccountFromKey(privateKey: string): Account;
+    loadConfigFromPath(configPath: string): Promise<CliConfigWithAccount>;
+    resolveConfigFileName(configPath: string, config: CliConfig, name?: string): string;
+    configExists(configFile: string): Promise<boolean>;
+    getConfigsWithNames(): Promise<Array<{
+        file: string;
+        name: string;
+    }>>;
+    getConfigData(configFile: string): Promise<CliConfig | undefined>;
+    setCurrentConfig(configFile: string): Promise<void>;
+    importConfig(sourcePath: string, name?: string): Promise<string>;
+    createConfigIfMissing(configFile: string, displayName: string, swarmUrl: string, account: Account, authUrl?: string): Promise<{
+        created: boolean;
+        updatedName: boolean;
+        updatedAuthUrl: boolean;
+        configFile: string;
+    }>;
+    updateConfigDisplayName(configFile: string, displayName?: string): Promise<{
+        status: DisplayNameUpdateStatus;
+        configFile: string;
+    }>;
+    updateConfigAuthUrl(configFile: string, authUrl?: string): Promise<DisplayNameUpdateStatus>;
+    findConfigsByPrivateKey(privateKey: string, swarmUrl: string, matchSwarmUrl: boolean): Promise<Array<{
+        file: string;
+        name: string;
+    }>>;
+}