@super-protocol/sp-cli 0.0.7 → 0.0.9

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

@@ -1,7 +1,7 @@
-import { select } from '@clack/prompts';
 import { Args, Flags } from '@oclif/core';
 import { Orders } from '@super-protocol/sdk-js';
 import { formatEther, parseEther } from 'viem/utils';
+import { promptService } from '../../utils/prompt.service.js';
 import { BaseCommand } from '../base.js';
 export default class WorkflowsExtendLease extends BaseCommand {
     static args = {
@@ -97,7 +97,6 @@ export default class WorkflowsExtendLease extends BaseCommand {
         }
     }
     async selectPrompt(options) {
-        const result = await select(options);
-        return this.ensurePromptValue(result);
+        return promptService.select(options);
     }
 }

package/dist/hooks/prerun/auth.js

@@ -2,6 +2,7 @@ import { BaseCommand } from '../../commands/base.js';
 import { AppContainer } from '../../lib/container.js';
 import logger from '../../logger.js';
 import { AuthService } from '../../services/auth.service.js';
+import { isInteractiveMode } from '../../utils/tty.js';
 const isBaseCommandClass = (commandClass) => commandClass.prototype instanceof BaseCommand;
 const getConfigFlag = (commandClass, argv) => {
     if (!isBaseCommandClass(commandClass)) {
@@ -47,7 +48,7 @@ const hook = async (opts) => {
         const { configManager, accountManager, providerClient } = container;
         const credentials = await configManager.get('auth');
         if (!credentials?.accessKey) {
-            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            if (!isInteractiveMode()) {
                 context.error('Authorization not found. Please run: sp account login', { exit: 1 });
             }
             const args = configFile ? ['--config', configFile] : [];

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

@@ -1,16 +1,8 @@
-import { confirm, select } from '@clack/prompts';
-import { ux } from '@oclif/core';
 import type pino from 'pino';
 import { type Account, type CliConfig } from '../config/config.schema.js';
 import type { IManager } from '../interfaces/manager.interface.js';
-type ConfirmPrompt = typeof confirm;
-type SelectPrompt = typeof select;
-type UxLike = Pick<typeof ux, 'error' | 'stdout'>;
 interface ConfigFileManagerOptions {
-    confirmPrompt?: ConfirmPrompt;
     runtimeConfigFile?: string;
-    selectPrompt?: SelectPrompt;
-    ux?: UxLike;
 }
 export declare class ConfigFileManager implements IManager {
     private readonly logger;
@@ -20,17 +12,19 @@ export declare class ConfigFileManager implements IManager {
     private readonly configFilePath;
     private configs;
     private readonly configsDir;
-    private readonly confirmPrompt;
     private runtimeConfigFile?;
-    private readonly selectPrompt;
-    private readonly ux;
     constructor(configDir: string, logger: pino.BaseLogger, options?: ConfigFileManagerOptions);
     createConfig(configFileName: string, name: string, url?: string, account?: Account): Promise<void>;
+    updateConfigName(configFileName: string, name: string): Promise<boolean>;
     deleteConfig(configName: string): Promise<void>;
-    deleteConfigByName(name?: string, force?: boolean): Promise<void>;
+    deleteConfigByName(name?: string): Promise<void>;
     getConfigData(configName: string): CliConfig | undefined;
     getConfigDir(): string;
     getConfigs(): string[];
+    getConfigWithName(name: string): {
+        file: string;
+        name: string;
+    };
     getConfigsWithNames(): Array<{
         file: string;
         name: string;

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

@@ -1,7 +1,5 @@
 import * as fs from 'node:fs';
 import path from 'node:path';
-import { confirm, isCancel, select } from '@clack/prompts';
-import { ux } from '@oclif/core';
 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';
@@ -16,24 +14,18 @@ export class ConfigFileManager {
         currentConfig: undefined,
     };
     configsDir;
-    confirmPrompt;
     runtimeConfigFile;
-    selectPrompt;
-    ux;
     constructor(configDir, logger, options = {}) {
         this.logger = logger;
         this.configDir = configDir;
         this.configFilePath = path.join(this.configDir, ConfigFileManager.CONFIG_FILE);
         this.configsDir = path.join(this.configDir, ConfigFileManager.CONFIGS_DIR);
-        this.confirmPrompt = options.confirmPrompt ?? confirm;
-        this.selectPrompt = options.selectPrompt ?? select;
-        this.ux = options.ux ?? ux;
         this.runtimeConfigFile = options.runtimeConfigFile;
     }
     async createConfig(configFileName, name, url, account) {
         const configPath = path.join(this.configsDir, configFileName);
         if (fs.existsSync(configPath)) {
-            throw new Error(`Configuration file already exists: ${configFileName}`);
+            throw new Error(`Account file already exists: ${configFileName}`);
         }
         const config = { name };
         if (url) {
@@ -49,70 +41,69 @@ export class ConfigFileManager {
         });
         this.logger.info({ configFileName, name, url }, 'Created new configuration');
     }
+    async updateConfigName(configFileName, name) {
+        const configPath = path.join(this.configsDir, configFileName);
+        const normalizedName = name.trim();
+        if (!normalizedName) {
+            throw new Error('Configuration name cannot be empty');
+        }
+        if (!fs.existsSync(configPath)) {
+            throw new Error(`Account file not found: ${configFileName}`);
+        }
+        let config;
+        try {
+            const raw = fs.readFileSync(configPath, 'utf8');
+            config = JSON.parse(raw);
+        }
+        catch (error) {
+            this.logger.warn({ configFileName, err: error }, 'Failed to read config data');
+            throw new Error(`Failed to read configuration: ${configFileName}`);
+        }
+        if (config.name === normalizedName) {
+            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');
+        return true;
+    }
     async deleteConfig(configName) {
         const configPath = path.join(this.configsDir, configName);
         if (!fs.existsSync(configPath)) {
-            throw new Error(`Configuration file not found: ${configName}`);
+            throw new Error(`Account file not found: ${configName}`);
         }
         await this.removeConfig(configName);
         fs.unlinkSync(configPath);
         this.logger.info({ configName }, 'Deleted configuration file');
     }
-    async deleteConfigByName(name, force) {
+    async deleteConfigByName(name) {
         const configs = this.getConfigsWithNames();
         if (configs.length === 0) {
-            this.ux.stdout('No configurations found');
-            return;
+            throw new Error('No configurations found');
         }
-        let configToDelete;
-        if (name) {
-            const config = configs.find((c) => c.name === name);
-            if (!config) {
-                this.ux.error(`Configuration not found: ${name}`);
-            }
-            configToDelete = config.file;
+        if (!name) {
+            throw new Error('Configuration name is required');
         }
-        else {
-            const selection = await this.selectPrompt({
-                message: 'Select configuration to delete:',
-                options: configs.map((config) => ({
-                    label: config.name,
-                    value: config.file,
-                })),
-            });
-            if (isCancel(selection)) {
-                this.ux.stdout('Deletion cancelled');
-                return;
-            }
-            configToDelete = selection;
-        }
-        const configToDeleteData = configs.find((c) => c.file === configToDelete);
-        const displayName = configToDeleteData?.name || configToDelete;
-        if (!force) {
-            const confirmed = await this.confirmPrompt({
-                initialValue: false,
-                message: `Are you sure you want to delete configuration "${displayName}"?`,
-            });
-            if (isCancel(confirmed) || !confirmed) {
-                this.ux.stdout('Deletion cancelled');
-                return;
-            }
+        const configToDeleteData = configs.find((c) => c.name === name || c.file === name);
+        if (!configToDeleteData) {
+            throw new Error(`Configuration not found: ${name}`);
         }
-        try {
-            await this.deleteConfig(configToDelete);
-            this.ux.stdout(`Successfully deleted configuration: ${displayName}`);
-            const newCurrent = this.getCurrentConfigFile();
-            if (newCurrent) {
-                const newCurrentConfig = configs.find((c) => c.file === newCurrent);
-                this.ux.stdout(`Current configuration is now: ${newCurrentConfig?.name || newCurrent}`);
-            }
-            else {
-                this.ux.stdout('No configurations remaining');
-                this.ux.stdout('Create a new account with: sp account login --name "Account Name" or sp auth login');
-            }
+        const configToDelete = configToDeleteData.file;
+        const displayName = configToDeleteData.name || configToDelete;
+        await this.deleteConfig(configToDelete);
+        this.logger.info({ displayName, configToDelete }, 'Successfully deleted configuration');
+        const newCurrent = this.getCurrentConfigFile();
+        if (newCurrent) {
+            const newCurrentConfig = configs.find((c) => c.file === newCurrent);
+            this.logger.info({ currentConfig: newCurrentConfig?.name || newCurrent }, 'Current configuration is now');
         }
-        catch (error) {
-            this.ux.error(`Failed to delete configuration: ${error instanceof Error ? error.message : String(error)}`);
+        else {
+            this.logger.info('No configurations remaining');
+            this.logger.info('Create a new account with: sp account login --name "Account Name" or sp account login');
         }
     }
     getConfigData(configName) {
@@ -138,6 +129,14 @@ export class ConfigFileManager {
         }
         return fs.readdirSync(this.configsDir).filter((file) => file.endsWith('.config.json'));
     }
+    getConfigWithName(name) {
+        const configs = this.getConfigsWithNames();
+        const config = configs.filter((config) => config.name === name || config.file === name).at(0);
+        if (!config) {
+            throw new Error(`Account with name ${name} not found`);
+        }
+        return config;
+    }
     getConfigsWithNames() {
         if (!fs.existsSync(this.configsDir)) {
             return [];

package/dist/utils/progress.js

@@ -14,6 +14,7 @@ export const createProgressPrinter = ({ action, done = 'completed', start, }) =>
             progressBar.stop(`${action} ${lastKey} ${done}`);
         }
         const progressBar = p.progress({ size: 100, style: 'block' });
+        lastKey = key;
         progressBar.start(`${start} ${key}`);
         progressBars[key] = progressBar;
         return progressBar;

package/dist/utils/prompt-flags.d.ts

@@ -0,0 +1,20 @@
+import type { Args, Flags } from '@oclif/core';
+type FlagDefinition = ReturnType<typeof Flags.string> | ReturnType<typeof Flags.integer> | ReturnType<typeof Flags.boolean>;
+type ArgDefinition = ReturnType<typeof Args.string> | ReturnType<typeof Args.integer> | ReturnType<typeof Args.boolean>;
+export interface MissingFlag {
+    name: string;
+    definition: FlagDefinition;
+    type: 'string' | 'integer' | 'boolean';
+}
+export interface MissingArg {
+    name: string;
+    definition: ArgDefinition;
+    type: 'string' | 'integer' | 'boolean';
+}
+export declare const findMissingRequiredFlags: (flags: Record<string, unknown>, flagDefinitions: Record<string, FlagDefinition> | undefined) => Promise<MissingFlag[]>;
+export declare const findMissingRequiredArgs: (args: Record<string, unknown>, argDefinitions: Record<string, ArgDefinition> | undefined) => Promise<MissingArg[]>;
+export declare const promptForFlag: (missingFlag: MissingFlag) => Promise<string | number | boolean>;
+export declare const promptForArg: (missingArg: MissingArg) => Promise<string | number | boolean>;
+export declare const formatMissingFlagsError: (missingFlags: MissingFlag[]) => string;
+export declare const formatMissingArgsError: (missingArgs: MissingArg[]) => string;
+export {};

package/dist/utils/prompt-flags.js

@@ -0,0 +1,121 @@
+import { promptService } from './prompt.service.js';
+const getSampleValue = (definition) => {
+    if (typeof definition.min === 'number') {
+        return String(definition.min);
+    }
+    if (typeof definition.max === 'number' && definition.max < 1) {
+        return String(definition.max);
+    }
+    return '1';
+};
+const inferTypeFromDefinition = async (definition, allowNo) => {
+    if (definition && typeof definition === 'object') {
+        const typedDefinition = definition;
+        if (typedDefinition.type === 'boolean' || typedDefinition.type === 'flag') {
+            return 'boolean';
+        }
+        if (typedDefinition.type === 'integer' || typedDefinition.type === 'number') {
+            return 'integer';
+        }
+        if (allowNo && typeof typedDefinition.allowNo === 'boolean') {
+            return 'boolean';
+        }
+    }
+    const parse = definition?.parse;
+    if (typeof parse === 'function') {
+        const sample = getSampleValue(definition);
+        try {
+            const parsed = await parse(sample, {}, definition);
+            if (typeof parsed === 'number') {
+                return 'integer';
+            }
+            if (typeof parsed === 'boolean') {
+                return 'boolean';
+            }
+        }
+        catch {
+            // Ignore parsing errors for type inference.
+        }
+    }
+    return 'string';
+};
+const parseIntegerValue = (name, input, definition) => {
+    if (!/^-?\d+$/.test(input)) {
+        throw new Error(`${name} must be a number`);
+    }
+    const num = Number.parseInt(input, 10);
+    if (definition.min !== undefined && num < definition.min) {
+        throw new Error(`Expected an integer greater than or equal to ${definition.min} but received: ${input}`);
+    }
+    if (definition.max !== undefined && num > definition.max) {
+        throw new Error(`Expected an integer less than or equal to ${definition.max} but received: ${input}`);
+    }
+    return num;
+};
+const getFlagType = async (definition) => inferTypeFromDefinition(definition, true);
+export const findMissingRequiredFlags = async (flags, flagDefinitions) => {
+    if (!flagDefinitions) {
+        return [];
+    }
+    const missing = [];
+    for (const [name, definition] of Object.entries(flagDefinitions)) {
+        if (definition.required && (flags[name] === undefined || flags[name] === null)) {
+            missing.push({
+                name,
+                definition,
+                type: await getFlagType(definition),
+            });
+        }
+    }
+    return missing;
+};
+const getArgType = async (definition) => inferTypeFromDefinition(definition, false);
+export const findMissingRequiredArgs = async (args, argDefinitions) => {
+    if (!argDefinitions) {
+        return [];
+    }
+    const missing = [];
+    for (const [name, definition] of Object.entries(argDefinitions)) {
+        if (definition.required && (args[name] === undefined || args[name] === null)) {
+            missing.push({
+                name,
+                definition,
+                type: await getArgType(definition),
+            });
+        }
+    }
+    return missing;
+};
+export const promptForFlag = async (missingFlag) => {
+    const description = missingFlag.definition.description;
+    const optionValues = missingFlag.definition.options;
+    if (missingFlag.type === 'string' && Array.isArray(optionValues) && optionValues.length > 0) {
+        const message = description ? `Select ${description}` : `Select ${missingFlag.name}`;
+        return promptService.select({
+            message,
+            options: optionValues.map((value) => ({
+                label: value,
+                value,
+            })),
+        });
+    }
+    const parseValue = missingFlag.type === 'integer'
+        ? (input) => parseIntegerValue(missingFlag.name, input, missingFlag.definition)
+        : undefined;
+    return promptService.promptForValue(missingFlag.name, description, missingFlag.type, parseValue);
+};
+export const promptForArg = async (missingArg) => {
+    const description = missingArg.definition.description;
+    const parseValue = missingArg.type === 'integer'
+        ? (input) => parseIntegerValue(missingArg.name, input, missingArg.definition)
+        : undefined;
+    return promptService.promptForValue(missingArg.name, description, missingArg.type, parseValue);
+};
+export const formatMissingFlagsError = (missingFlags) => {
+    const flagNames = missingFlags.map((f) => `--${f.name}`).join(', ');
+    return `Missing required flags: ${flagNames}. Please provide them or run in interactive mode.`;
+};
+export const formatMissingArgsError = (missingArgs) => {
+    const argNames = missingArgs.map((a) => `<${a.name}>`).join(', ');
+    return `Missing required arguments: ${argNames}. Please provide them or run in interactive mode.`;
+};

package/dist/utils/prompt.service.d.ts

@@ -0,0 +1,23 @@
+import { type ConfirmOptions as ClackConfirmOptions, type PasswordOptions as ClackPasswordOptions, type SelectOptions as ClackSelectOptions, type TextOptions as ClackTextOptions } from '@clack/prompts';
+export type TextOptions = ClackTextOptions;
+export type ConfirmOptions = ClackConfirmOptions;
+export type SelectOptions<T> = ClackSelectOptions<T>;
+export type PasswordOptions = ClackPasswordOptions;
+type ParseValue = (input: string) => string | number | boolean;
+export declare class NonInteractiveError extends Error {
+    constructor(message: string);
+}
+declare class PromptService {
+    private _isInteractive;
+    setInteractiveMode(value: boolean): void;
+    get isInteractive(): boolean;
+    private checkInteractive;
+    text(options: ClackTextOptions): Promise<string>;
+    confirm(options: ClackConfirmOptions): Promise<boolean>;
+    select<T>(options: ClackSelectOptions<T>): Promise<T>;
+    password(options: ClackPasswordOptions): Promise<string>;
+    ensureValue<T>(value: symbol | T, errorMessage?: string): T;
+    promptForValue(name: string, description: string | undefined, type: 'string' | 'integer' | 'boolean', parseValue?: ParseValue): Promise<string | number | boolean>;
+}
+export declare const promptService: PromptService;
+export {};

package/dist/utils/prompt.service.js

@@ -0,0 +1,107 @@
+import { confirm as clackConfirm, password as clackPassword, select as clackSelect, text as clackText, isCancel, } from '@clack/prompts';
+import { isInteractiveMode } from './tty.js';
+export class NonInteractiveError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NonInteractiveError';
+    }
+}
+class PromptService {
+    _isInteractive = null;
+    setInteractiveMode(value) {
+        this._isInteractive = value;
+    }
+    get isInteractive() {
+        if (this._isInteractive === null) {
+            this._isInteractive = isInteractiveMode();
+        }
+        return this._isInteractive;
+    }
+    checkInteractive(operation) {
+        if (!this.isInteractive) {
+            throw new NonInteractiveError(`Cannot ${operation} in non-interactive mode. Use appropriate flags or run without --no-tty.`);
+        }
+    }
+    async text(options) {
+        this.checkInteractive('prompt for text input');
+        const result = await clackText(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async confirm(options) {
+        if (!this.isInteractive) {
+            if (options.initialValue !== undefined) {
+                return options.initialValue;
+            }
+            throw new NonInteractiveError('Cannot prompt for confirmation in non-interactive mode. Use --force or run without --no-tty.');
+        }
+        const result = await clackConfirm(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async select(options) {
+        this.checkInteractive('show selection menu');
+        const result = await clackSelect(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async password(options) {
+        this.checkInteractive('prompt for password');
+        const result = await clackPassword(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    ensureValue(value, errorMessage = 'Operation cancelled.') {
+        if (isCancel(value)) {
+            throw new Error(errorMessage);
+        }
+        return value;
+    }
+    async promptForValue(name, description, type, parseValue) {
+        this.checkInteractive('prompt for value');
+        const fullDescription = description ? ` (${description})` : '';
+        if (type === 'boolean') {
+            const message = `Enable ${name}${fullDescription}?`;
+            return await this.confirm({ message });
+        }
+        const message = `Please provide ${name}${fullDescription}:`;
+        const parseInput = (value) => {
+            if (parseValue) {
+                return parseValue(value);
+            }
+            if (type === 'integer') {
+                const num = Number.parseInt(value, 10);
+                if (Number.isNaN(num)) {
+                    throw new Error(`${name} must be a number`);
+                }
+                return num;
+            }
+            return value;
+        };
+        const result = await this.text({
+            message,
+            validate: (value) => {
+                if (!value || value.trim() === '') {
+                    return `${name} is required`;
+                }
+                try {
+                    parseInput(value);
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+                return;
+            },
+        });
+        return parseInput(result);
+    }
+}
+export const promptService = new PromptService();

package/dist/utils/tty.d.ts

@@ -0,0 +1 @@
+export declare const isInteractiveMode: (ttyFlag?: boolean) => boolean;

package/dist/utils/tty.js

@@ -0,0 +1,3 @@
+export const isInteractiveMode = (ttyFlag) => {
+    return ttyFlag ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+};