@super-protocol/sp-cli 0.0.7 → 0.0.9

package/dist/commands/account/login.js

@@ -1,12 +1,14 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { confirm, isCancel, text } from '@clack/prompts';
 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 { AuthService } from '../../services/auth.service.js';
 import { StorageService } from '../../services/storage.service.js';
-import { getConfigNameFromCredentials } from '../../utils/helper.js';
+import { getConfigName, getConfigNameFromCredentials, preparePath, readJsonFile, } 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'];
@@ -23,6 +25,9 @@ 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',
             hidden: true,
@@ -36,8 +41,7 @@ export default class AccountLoginCommand extends BaseAccountCommand {
     configFileManager;
     shouldSkipLogin = false;
     async inputPrompt(options) {
-        const result = await text(options);
-        return this.ensurePromptValue(result);
+        return promptService.text(options);
     }
     async checkStorage() {
         await this.container
@@ -91,18 +95,14 @@ 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();
         return trimmed || fallback;
     }
     async confirmPrompt(message, initialValue = true) {
-        const result = await confirm({ initialValue, message });
-        if (isCancel(result)) {
-            this.error('Operation cancelled.', { exit: 1 });
-        }
-        return Boolean(result);
+        return promptService.confirm({ initialValue, message });
     }
     createAccountFromKey(privateKey) {
         try {
@@ -120,10 +120,22 @@ export default class AccountLoginCommand extends BaseAccountCommand {
     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 configuration: ${displayName}`);
+        this.log(`Created account: ${displayName}`);
+    }
+    async updateConfigDisplayName(configFile, displayName) {
+        if (!displayName) {
+            return;
+        }
+        const updated = await this.configFileManager.updateConfigName(configFile, displayName);
+        if (updated) {
+            this.log(`Updated account name to "${displayName}"`);
+            return;
+        }
+        this.log(`Account name: "${displayName}"`);
     }
     findConfigsByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
         const normalizedKey = privateKey.trim().toLowerCase();
@@ -164,7 +176,7 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         }
         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;
@@ -176,7 +188,7 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         await this.createConfigIfMissing(configFile, name, providerUrl, account);
         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;
@@ -184,41 +196,120 @@ export default class AccountLoginCommand extends BaseAccountCommand {
         }
         await this.configFileManager.setCurrentConfig(configFile);
     }
-    async resolveByPrivateKey(privateKey, providerUrl, matchProviderUrl) {
+    assertConfigHasAccount(config) {
+        if (!config.account?.privateKey) {
+            throw new Error('Account private key is required for import.');
+        }
+    }
+    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;
+        }
+        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 baseName = path.basename(configPath, path.extname(configPath));
+        return getConfigName(baseName);
+    }
+    async resolveByPath(rawPath, name) {
+        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 desiredName = name?.trim();
+        const privateKey = config.account.privateKey;
+        const providerUrl = (config.providerUrl ?? PROVIDER_URL).trim();
+        const matches = this.findConfigsByPrivateKey(privateKey, providerUrl, 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 })),
+                    });
+                }
+            }
+            this.log('Account already exists. Nothing to import.');
+            await this.updateConfigDisplayName(selectedFile, desiredName);
+            await this.configFileManager.setCurrentConfig(selectedFile);
+            return;
+        }
+        if (existsSync(targetPath)) {
+            const existingConfig = this.configFileManager.getConfigData(targetFile);
+            const existingKey = existingConfig?.account?.privateKey?.trim().toLowerCase();
+            const existingUrl = (existingConfig?.providerUrl ?? PROVIDER_URL).trim();
+            const importedKey = privateKey.trim().toLowerCase();
+            if (!existingKey || existingKey !== importedKey || existingUrl !== providerUrl) {
+                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);
+            return;
+        }
+        try {
+            const importedFile = await this.configFileManager.importConfig(sourcePath, name);
+            await this.configFileManager.setCurrentConfig(importedFile);
+        }
+        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);
+        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 configs: ${matches.map((conf) => conf.name).join(',')} Selected first: ${matches[0].name}`);
+                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 configurations found for this private key. Select one:',
+                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);
             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);
         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;
@@ -228,18 +319,27 @@ export default class AccountLoginCommand extends BaseAccountCommand {
     }
     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 });
         }
         const providerUrl = (url || PROVIDER_URL).trim();
-        if (name) {
-            await this.resolveByName(name, privateKey, providerUrl);
+        if (configPath) {
+            await this.resolveByPath(configPath, name);
             return;
         }
         if (privateKey) {
-            await this.resolveByPrivateKey(privateKey, providerUrl, Boolean(url));
+            await this.resolveByPrivateKey(privateKey, providerUrl, Boolean(url), name);
+            return;
+        }
+        if (name) {
+            await this.resolveByName(name, privateKey, providerUrl);
+            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 { name } = this.flags;
         const configs = 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 = 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/base.js

@@ -1,7 +1,21 @@
-import { isCancel } from '@clack/prompts';
 import { Command, Flags } from '@oclif/core';
 import { AppContainer } from '../lib/container.js';
 import logger from '../logger.js';
+import { findMissingRequiredArgs, findMissingRequiredFlags, formatMissingArgsError, formatMissingFlagsError, promptForArg, promptForFlag, } from '../utils/prompt-flags.js';
+import { promptService } from '../utils/prompt.service.js';
+import { isInteractiveMode } from '../utils/tty.js';
+const relaxRequired = (definitions) => {
+    if (!definitions) {
+        return definitions;
+    }
+    return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+        name,
+        {
+            ...definition,
+            required: false,
+        },
+    ]));
+};
 export class BaseCommand extends Command {
     static authenticate = true;
     static baseFlags = {
@@ -11,6 +25,12 @@ export class BaseCommand extends Command {
             required: false,
             summary: 'Specify config file.',
         }),
+        tty: Flags.boolean({
+            allowNo: true,
+            helpGroup: 'GLOBAL',
+            required: false,
+            summary: 'Force or disable interactive mode (use --no-tty to disable).',
+        }),
     };
     static enableJsonFlag = true;
     args;
@@ -22,24 +42,89 @@ export class BaseCommand extends Command {
         this.logger = logger.getPino();
     }
     ensurePromptValue(value, errorMessage = 'Operation cancelled.') {
-        if (isCancel(value)) {
-            this.error(errorMessage);
+        try {
+            return promptService.ensureValue(value, errorMessage);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
         }
-        return value;
     }
     async init() {
         await super.init();
-        const { args, flags } = await this.parse({
-            args: this.ctor.args,
-            baseFlags: super.ctor.baseFlags,
+        const allFlags = { ...this.ctor.flags, ...super.ctor.baseFlags };
+        const relaxedArgs = relaxRequired(this.ctor.args);
+        const relaxedFlags = relaxRequired(this.ctor.flags);
+        const relaxedBaseFlags = relaxRequired(super.ctor.baseFlags);
+        let parsedResult = await this.parse({
+            args: relaxedArgs,
+            baseFlags: relaxedBaseFlags,
             enableJsonFlag: this.ctor.enableJsonFlag,
-            flags: this.ctor.flags,
-            strict: this.ctor.strict,
+            flags: relaxedFlags,
+            strict: false,
         });
-        this.flags = flags;
-        this.args = args;
+        const isInteractive = isInteractiveMode(parsedResult.flags.tty);
+        promptService.setInteractiveMode(isInteractive);
+        const missingFlags = await findMissingRequiredFlags(parsedResult.flags, allFlags);
+        const missingArgs = await findMissingRequiredArgs(parsedResult.args, this.ctor.args);
+        if (missingFlags.length > 0 || missingArgs.length > 0) {
+            if (!isInteractive) {
+                const errors = [];
+                if (missingFlags.length > 0) {
+                    errors.push(formatMissingFlagsError(missingFlags));
+                }
+                if (missingArgs.length > 0) {
+                    errors.push(formatMissingArgsError(missingArgs));
+                }
+                this.error(errors.join(' '), { exit: 1 });
+            }
+            const argValues = [];
+            for (const missingArg of missingArgs) {
+                const value = await promptForArg(missingArg);
+                argValues.push(String(value));
+            }
+            const flagPairs = [];
+            for (const missingFlag of missingFlags) {
+                const value = await promptForFlag(missingFlag);
+                if (missingFlag.type === 'boolean') {
+                    const boolValue = Boolean(value);
+                    if (boolValue) {
+                        flagPairs.push(`--${missingFlag.name}`);
+                    }
+                    else if ('allowNo' in missingFlag.definition &&
+                        Boolean(missingFlag.definition.allowNo)) {
+                        flagPairs.push(`--no-${missingFlag.name}`);
+                    }
+                    else {
+                        this.error(`Flag --${missingFlag.name} is required and only supports "true".`);
+                    }
+                }
+                else {
+                    flagPairs.push(`--${missingFlag.name}`, String(value));
+                }
+            }
+            const updatedArgv = [...this.argv, ...argValues, ...flagPairs];
+            this.argv = updatedArgv;
+            parsedResult = await this.parse({
+                args: this.ctor.args,
+                baseFlags: super.ctor.baseFlags,
+                enableJsonFlag: this.ctor.enableJsonFlag,
+                flags: this.ctor.flags,
+                strict: this.ctor.strict,
+            });
+        }
+        else if (this.ctor.strict) {
+            parsedResult = await this.parse({
+                args: this.ctor.args,
+                baseFlags: super.ctor.baseFlags,
+                enableJsonFlag: this.ctor.enableJsonFlag,
+                flags: this.ctor.flags,
+                strict: true,
+            });
+        }
+        this.flags = parsedResult.flags;
+        this.args = parsedResult.args;
         this.container = AppContainer.container.setupRuntimeConfig({
-            configFile: flags.config,
+            configFile: parsedResult.flags.config,
         });
     }
 }

package/dist/commands/storage/base.js

@@ -1,8 +1,8 @@
-import { password, select, text } from '@clack/prompts';
 import { StorageType } from '@super-protocol/provider-client';
 import { BaseCommand } from '../../commands/base.js';
 import { S3_REGION } from '../../constants.js';
 import { StorageService } from '../../services/storage.service.js';
+import { promptService } from '../../utils/prompt.service.js';
 export class BaseStorageCommand extends BaseCommand {
     currentDir = process.cwd();
     storageService;
@@ -14,25 +14,25 @@ export class BaseStorageCommand extends BaseCommand {
     }
     async promptS3Credentials() {
         const region = S3_REGION;
-        const readAccessKeyId = this.ensurePromptValue(await text({
+        const readAccessKeyId = (await promptService.text({
             message: 'Read access key ID',
             validate(value) {
                 return value ? undefined : 'Read access key ID is required';
             },
         })).trim();
-        const readSecretAccessKey = this.ensurePromptValue(await password({
+        const readSecretAccessKey = (await promptService.password({
             message: 'Read secret access key',
             validate(value) {
                 return value ? undefined : 'Read secret access key is required';
             },
         })).trim();
-        const writeAccessKeyId = this.ensurePromptValue(await text({
+        const writeAccessKeyId = (await promptService.text({
             message: 'Write access key ID',
             validate(value) {
                 return value ? undefined : 'Write access key ID is required';
             },
         })).trim();
-        const writeSecretAccessKey = this.ensurePromptValue(await password({
+        const writeSecretAccessKey = (await promptService.password({
             message: 'Write secret access key',
             validate(value) {
                 return value ? undefined : 'Write secret access key is required';
@@ -47,20 +47,20 @@ export class BaseStorageCommand extends BaseCommand {
         };
     }
     async promptStoragePayload() {
-        const storageType = this.ensurePromptValue(await select({
+        const storageType = await promptService.select({
             message: 'Select storage type',
             options: [
                 { label: 'S3', value: StorageType.S3 },
                 { label: 'StorJ', value: StorageType.StorJ },
             ],
-        }));
-        const bucket = this.ensurePromptValue(await text({
+        });
+        const bucket = (await promptService.text({
             message: 'Bucket name',
             validate(value) {
                 return value ? undefined : 'Bucket is required';
             },
         })).trim();
-        const prefix = this.ensurePromptValue(await text({
+        const prefix = (await promptService.text({
             defaultValue: '/',
             initialValue: '/',
             message: 'Prefix',
@@ -82,13 +82,13 @@ export class BaseStorageCommand extends BaseCommand {
         return storage;
     }
     async promptStorJCredentials() {
-        const readAccessToken = this.ensurePromptValue(await password({
+        const readAccessToken = (await promptService.password({
             message: 'Read access token',
             validate(value) {
                 return value ? undefined : 'Read access token is required';
             },
         })).trim();
-        const writeAccessToken = this.ensurePromptValue(await password({
+        const writeAccessToken = (await promptService.password({
             message: 'Write access token',
             validate(value) {
                 return value ? undefined : 'Write access token is required';

package/dist/commands/storage/select.js

@@ -1,5 +1,5 @@
-import { select } from '@clack/prompts';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { promptService } from '../../utils/prompt.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageSelect extends BaseStorageCommand {
     static description = 'Select a storage that will be used by subsequent commands.';
@@ -7,13 +7,13 @@ export default class StorageSelect extends BaseStorageCommand {
     async run() {
         try {
             const storages = await this.storageService.requestStorages();
-            const storageId = this.ensurePromptValue(await select({
+            const storageId = await promptService.select({
                 message: 'Select storage',
                 options: storages.map((storage) => ({
                     label: this.storageService.getLabel(storage),
                     value: storage.id,
                 })),
-            }));
+            });
             if (!storageId) {
                 this.error('Storage ID is required');
             }

package/dist/commands/storage/update.js

@@ -1,9 +1,9 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { confirm, select, text } from '@clack/prompts';
 import { Flags } from '@oclif/core';
 import { StorageType, } from '@super-protocol/provider-client';
 import { StoragesUndefinedError } from '../../services/storage.service.js';
+import { promptService } from '../../utils/prompt.service.js';
 import { BaseStorageCommand } from './base.js';
 export default class StorageUpdate extends BaseStorageCommand {
     static description = 'Update the configuration of an existing storage.';
@@ -39,10 +39,10 @@ export default class StorageUpdate extends BaseStorageCommand {
                 if (!options || options.length === 0) {
                     throw new StoragesUndefinedError('No storages available to update');
                 }
-                storageId = this.ensurePromptValue(await select({
+                storageId = await promptService.select({
                     message: 'Select storage to update',
                     options,
-                }));
+                });
             }
             if (!storageId) {
                 this.error('Storage ID is required');
@@ -148,14 +148,14 @@ export default class StorageUpdate extends BaseStorageCommand {
     }
     async promptStorageUpdate(existingStorage) {
         const payload = {};
-        const bucket = this.ensurePromptValue(await text({
+        const bucket = (await promptService.text({
             defaultValue: existingStorage?.bucket ?? '',
             message: 'Bucket name (leave empty to keep current)',
         })).trim();
         if (bucket) {
             payload.bucket = bucket;
         }
-        const prefix = this.ensurePromptValue(await text({
+        const prefix = (await promptService.text({
             defaultValue: existingStorage?.prefix ?? '',
             message: 'Prefix (leave empty to keep current)',
         })).trim();
@@ -163,27 +163,27 @@ export default class StorageUpdate extends BaseStorageCommand {
             payload.prefix = prefix;
         }
         let newStorageType;
-        const shouldChangeType = this.ensurePromptValue(await confirm({
+        const shouldChangeType = await promptService.confirm({
             initialValue: false,
             message: existingStorage
                 ? `Change storage type? (current: ${existingStorage.storageType})`
                 : 'Change storage type?',
-        }));
+        });
         if (shouldChangeType) {
-            newStorageType = this.ensurePromptValue(await select({
+            newStorageType = await promptService.select({
                 message: 'Select new storage type',
                 options: [
                     { label: 'Amazon S3', value: StorageType.S3 },
                     { label: 'StorJ', value: StorageType.StorJ },
                 ],
-            }));
+            });
             payload.storageType = newStorageType;
         }
         const effectiveType = newStorageType ?? existingStorage?.storageType;
         const credentialsRequired = Boolean(newStorageType);
         if (effectiveType) {
             const updateCredentials = credentialsRequired ||
-                this.ensurePromptValue(await confirm({
+                (await promptService.confirm({
                     initialValue: false,
                     message: `Update ${effectiveType} credentials?`,
                 }));

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

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