@super-protocol/sp-cli 0.0.7 → 0.0.8

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: {

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/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,16 @@
+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 PromptService {
+    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,75 @@
+import { confirm as clackConfirm, password as clackPassword, select as clackSelect, text as clackText, isCancel, } from '@clack/prompts';
+export class PromptService {
+    async text(options) {
+        const result = await clackText(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async confirm(options) {
+        const result = await clackConfirm(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async select(options) {
+        const result = await clackSelect(options);
+        if (isCancel(result)) {
+            throw new Error('Operation cancelled.');
+        }
+        return result;
+    }
+    async password(options) {
+        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) {
+        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);
+};