@super-protocol/sp-cli 0.0.6 → 0.0.8

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

@@ -1,7 +1,7 @@
-import { confirm, isCancel, select } from '@clack/prompts';
-import { ux } from '@oclif/core';
 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';
@@ -9,11 +9,10 @@ import { getConfigName } from '../utils/helper.js';
 export class ConfigFileManager {
     logger;
     static CONFIG_FILE = 'config.json';
-    static CONFIGS_DIR = 'configs';
+    static CONFIGS_DIR = 'accounts';
     configDir;
     configFilePath;
     configs = {
-        configs: [],
         currentConfig: undefined,
     };
     configsDir;
@@ -31,13 +30,7 @@ export class ConfigFileManager {
         this.ux = options.ux ?? ux;
         this.runtimeConfigFile = options.runtimeConfigFile;
     }
-    async addConfig(configName) {
-        if (!this.configs.configs.includes(configName)) {
-            this.configs.configs.push(configName);
-            await this.save();
-        }
-    }
-    async createConfig(configFileName, name, url) {
+    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}`);
@@ -46,12 +39,14 @@ export class ConfigFileManager {
         if (url) {
             config.providerUrl = url;
         }
+        if (account) {
+            config.account = account;
+        }
         fs.writeFileSync(configPath, JSON.stringify(config, undefined, 2), {
             encoding: 'utf8',
             flag: 'w',
             mode: FILE_ACCESS_PERMS,
         });
-        await this.addConfig(configFileName);
         this.logger.info({ configFileName, name, url }, 'Created new configuration');
     }
     async deleteConfig(configName) {
@@ -71,7 +66,7 @@ export class ConfigFileManager {
         }
         let configToDelete;
         if (name) {
-            const config = configs.find(c => c.name === name);
+            const config = configs.find((c) => c.name === name);
             if (!config) {
                 this.ux.error(`Configuration not found: ${name}`);
             }
@@ -80,7 +75,7 @@ export class ConfigFileManager {
         else {
             const selection = await this.selectPrompt({
                 message: 'Select configuration to delete:',
-                options: configs.map(config => ({
+                options: configs.map((config) => ({
                     label: config.name,
                     value: config.file,
                 })),
@@ -91,7 +86,7 @@ export class ConfigFileManager {
             }
             configToDelete = selection;
         }
-        const configToDeleteData = configs.find(c => c.file === configToDelete);
+        const configToDeleteData = configs.find((c) => c.file === configToDelete);
         const displayName = configToDeleteData?.name || configToDelete;
         if (!force) {
             const confirmed = await this.confirmPrompt({
@@ -108,12 +103,12 @@ export class ConfigFileManager {
             this.ux.stdout(`Successfully deleted configuration: ${displayName}`);
             const newCurrent = this.getCurrentConfigFile();
             if (newCurrent) {
-                const newCurrentConfig = configs.find(c => c.file === 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 configuration with: sp config create --name "Config Name" or sp auth login');
+                this.ux.stdout('Create a new account with: sp account login --name "Account Name" or sp auth login');
             }
         }
         catch (error) {
@@ -138,10 +133,19 @@ export class ConfigFileManager {
         return this.configsDir;
     }
     getConfigs() {
-        return [...this.configs.configs];
+        if (!fs.existsSync(this.configsDir)) {
+            return [];
+        }
+        return fs.readdirSync(this.configsDir).filter((file) => file.endsWith('.config.json'));
     }
     getConfigsWithNames() {
-        return this.configs.configs.map(configFile => {
+        if (!fs.existsSync(this.configsDir)) {
+            return [];
+        }
+        const configFiles = fs
+            .readdirSync(this.configsDir)
+            .filter((file) => file.endsWith('.config.json'));
+        return configFiles.map((configFile) => {
             const configPath = path.join(this.configsDir, configFile);
             let name = configFile;
             try {
@@ -218,7 +222,6 @@ export class ConfigFileManager {
         }
         fs.copyFileSync(sourcePath, targetPath);
         fs.chmodSync(targetPath, FILE_ACCESS_PERMS);
-        await this.addConfig(targetFileName);
         this.logger.info({ sourcePath, targetFileName }, 'Imported configuration');
         return targetFileName;
     }
@@ -231,12 +234,10 @@ export class ConfigFileManager {
         await this.load();
     }
     async removeConfig(configName) {
-        const index = this.configs.configs.indexOf(configName);
-        if (index !== -1) {
-            this.configs.configs.splice(index, 1);
-            if (this.configs.currentConfig === configName) {
-                this.configs.currentConfig = this.configs.configs[0];
-            }
+        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();
         }
     }
@@ -245,9 +246,6 @@ export class ConfigFileManager {
         if (!fs.existsSync(configPath)) {
             throw new Error(`Configuration file not found: ${configName}`);
         }
-        if (!this.configs.configs.includes(configName)) {
-            this.configs.configs.push(configName);
-        }
         this.configs.currentConfig = configName;
         await this.save();
     }
@@ -256,10 +254,16 @@ export class ConfigFileManager {
     }
     ensureDirectories() {
         if (!fs.existsSync(this.configDir)) {
-            fs.mkdirSync(this.configDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+            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 });
+            fs.mkdirSync(this.configsDir, {
+                mode: DIR_ACCESS_PERMS,
+                recursive: true,
+            });
         }
     }
     async load() {
@@ -277,7 +281,6 @@ export class ConfigFileManager {
         catch (error) {
             this.logger.error({ err: error }, 'Failed to load config manager file, using defaults');
             this.configs = {
-                configs: [],
                 currentConfig: undefined,
             };
             await this.save();

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

@@ -1,6 +1,6 @@
-import pino from 'pino';
-import { Auth, CliConfig } from '../config/config.schema.js';
-import { IConfigManager } from '../interfaces/config-manager.interface.js';
+import type pino from 'pino';
+import type { Auth, CliConfig } from '../config/config.schema.js';
+import type { IConfigManager } from '../interfaces/config-manager.interface.js';
 export declare class ConfigManager implements IConfigManager {
     private readonly configFile;
     private readonly logger;
@@ -8,14 +8,14 @@ export declare class ConfigManager implements IConfigManager {
     private readonly configDir;
     constructor(configFile: string, logger: pino.BaseLogger);
     get<K extends keyof CliConfig, V extends CliConfig[K]>(key: K): Promise<undefined | V>;
-    getConfig(): CliConfig;
+    private getConfig;
     getCookies(): Promise<unknown>;
     getCredentials(): Promise<{
         accessKey: string;
     } | undefined>;
     init(): Promise<void>;
     load(): Promise<CliConfig>;
-    makeBackup(): void;
+    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>;

package/dist/managers/config-manager.js

@@ -1,6 +1,6 @@
-import { ux } from '@oclif/core';
 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 { ConfigurationNotFoundError } from '../errors.js';
 export class ConfigManager {
@@ -62,7 +62,10 @@ export class ConfigManager {
         }
     }
     async save() {
-        fs.mkdirSync(this.configDir, { mode: DIR_ACCESS_PERMS, recursive: true });
+        fs.mkdirSync(this.configDir, {
+            mode: DIR_ACCESS_PERMS,
+            recursive: true,
+        });
         this.logger.debug({ configFile: this.getConfigPath() }, 'Saving config file');
         fs.writeFileSync(this.getConfigPath(), JSON.stringify(this.config, undefined, '  '), {
             encoding: 'utf8',

package/dist/middlewares/auth-middleware.d.ts

@@ -1,6 +1,6 @@
 import type { MiddlewareFn, ProviderClient } from '@super-protocol/provider-client';
 import type pino from 'pino';
-import { type Auth } from '../config/config.schema.js';
+import type { Auth } from '../config/config.schema.js';
 interface CredentialsStorage {
     getCredentials(): Promise<Auth | undefined>;
     setCredentials(auth: Auth): void;

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

@@ -1,7 +1,7 @@
-import { ProviderClient } from '@super-protocol/provider-client';
-import pino from 'pino';
-import { AccountManager } from '../managers/account-manager.js';
-import { ConfigManager } from '../managers/config-manager.js';
+import type { ProviderClient } from '@super-protocol/provider-client';
+import type pino from 'pino';
+import type { AccountManager } from '../managers/account-manager.js';
+import type { ConfigManager } from '../managers/config-manager.js';
 export declare class AuthError extends Error {
 }
 export declare class AuthService {
@@ -10,15 +10,10 @@ export declare class AuthService {
     private readonly providerClient;
     private readonly logger;
     constructor(accountManager: AccountManager, configManager: ConfigManager, providerClient: ProviderClient, logger: pino.BaseLogger);
-    auth(): Promise<void>;
-    getTokens(nonce: string): Promise<void>;
-    getUserNonce(address: string): Promise<{
-        error: {
-            message: string;
-            statusCode: number;
-        } | undefined;
-        user: {
-            nonce?: string;
-        } | undefined;
-    }>;
+    private hasValidRefreshCookie;
+    auth(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    private getTokens;
+    private getUserNonce;
 }

package/dist/services/auth.service.js

@@ -1,5 +1,31 @@
+import { decode } from 'jsonwebtoken';
+import { CookieJar } from 'tough-cookie';
+import { PROVIDER_URL } from '../constants.js';
 export class AuthError extends Error {
 }
+function isAccessKeyExpired(accessKey) {
+    try {
+        const payload = decode(accessKey);
+        if (!payload || typeof payload.exp !== 'number') {
+            return true;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        return now >= payload.exp;
+    }
+    catch {
+        return true;
+    }
+}
+function isCookieExpired(cookie) {
+    if (!cookie.expires || cookie.expires === 'Infinity') {
+        return false;
+    }
+    const expiresAt = cookie.expires.getTime();
+    if (!Number.isFinite(expiresAt)) {
+        return true;
+    }
+    return Date.now() >= expiresAt;
+}
 export class AuthService {
     accountManager;
     configManager;
@@ -11,7 +37,45 @@ export class AuthService {
         this.providerClient = providerClient;
         this.logger = logger;
     }
-    async auth() {
+    async hasValidRefreshCookie(baseUrl) {
+        let stored;
+        try {
+            stored = await this.configManager.getCookies();
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, 'Failed to read cookies from config');
+            return false;
+        }
+        if (!stored || typeof stored !== 'object') {
+            return false;
+        }
+        try {
+            const jar = CookieJar.fromJSON(stored);
+            const cookies = await jar.getCookies(baseUrl, { expire: false });
+            return cookies.some((cookie) => cookie.key.toLowerCase().includes('refresh') && cookie.value && !isCookieExpired(cookie));
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, 'Failed to parse cookies');
+            return false;
+        }
+    }
+    async auth(options = {}) {
+        if (!options.force) {
+            const credentials = await this.configManager.getCredentials();
+            const accessKey = credentials?.accessKey;
+            if (accessKey && !isAccessKeyExpired(accessKey)) {
+                this.logger.debug('Access key is not expired, skipping authorization');
+                return;
+            }
+            if (accessKey) {
+                const providerUrl = (await this.configManager.get('providerUrl')) || PROVIDER_URL;
+                const hasRefreshCookie = await this.hasValidRefreshCookie(providerUrl);
+                if (hasRefreshCookie) {
+                    this.logger.debug('Access key expired but refresh cookie exists, skipping authorization');
+                    return;
+                }
+            }
+        }
         const address = this.accountManager.getAddress();
         const { error: nonceError, user } = await this.getUserNonce(address);
         if (nonceError && nonceError.statusCode === 404) {
@@ -25,7 +89,7 @@ export class AuthService {
                 this.logger.debug({ signUpError }, 'Error signing up');
                 const { error: nonceError, user } = await this.getUserNonce(address);
                 this.logger.debug({ nonceError, user }, 'Requesting nonce again');
-                if (user && user.nonce) {
+                if (user?.nonce) {
                     await this.getTokens(user.nonce);
                 }
                 else {
@@ -45,7 +109,7 @@ export class AuthService {
                 await this.getTokens(nonce);
             }
         }
-        else if (user && user.nonce) {
+        else if (user?.nonce) {
             this.logger.debug({ user }, 'Requesting for existed user');
             await this.getTokens(user.nonce);
         }
@@ -55,7 +119,7 @@ export class AuthService {
     }
     async getTokens(nonce) {
         const signature = await this.accountManager.createSign(nonce);
-        const { data: tokenResponse, error, } = await this.providerClient.POST('/api/auth/token', {
+        const { data: tokenResponse, error } = await this.providerClient.POST('/api/auth/token', {
             body: {
                 address: this.accountManager.getAddress(),
                 provider: 'sp-cli',
@@ -71,7 +135,9 @@ export class AuthService {
             this.logger.error({ response: tokenResponse }, 'Unexpected token response');
             throw new AuthError('Provider returned an unexpected token response.');
         }
-        await this.configManager.setCredentials({ accessKey: accessToken });
+        await this.configManager.setCredentials({
+            accessKey: accessToken,
+        });
     }
     async getUserNonce(address) {
         try {

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

@@ -1,6 +1,6 @@
-import { EncryptionWithIV, Resource, RuntimeInputInfo } from '@super-protocol/dto-js';
-import { AddStorageDto, ProviderClient, StorageResponseDto, UpdateStorageDto } from '@super-protocol/provider-client';
-import pino from 'pino';
+import { type EncryptionWithIV, type Resource, type RuntimeInputInfo } from '@super-protocol/dto-js';
+import { type AddStorageDto, type ProviderClient, type StorageResponseDto, type UpdateStorageDto } from '@super-protocol/provider-client';
+import type pino from 'pino';
 export declare class StorageError extends Error {
 }
 export declare class StoragesUndefinedError extends StorageError {

package/dist/services/storage.service.js

@@ -4,11 +4,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import * as fs from 'node:fs/promises';
+import { basename, dirname } from 'node:path';
 import { StorageResourceSchema, StorageType, } from '@super-protocol/dto-js';
 import { ResourceType, } from '@super-protocol/provider-client';
 import { download, upload } from '@super-protocol/sp-files-addon';
-import * as fs from 'node:fs/promises';
-import { basename, dirname } from 'node:path';
 import { Value } from 'typebox/value';
 import { Retryable } from 'typescript-retry-decorator';
 import { S3_ENDPOINT } from '../constants.js';
@@ -24,7 +24,9 @@ export class StorageUpdateError extends StorageError {
 }
 export class StorageGetError extends StorageError {
 }
-export const generateExternalId = () => Array.from({ length: 16 }).map(() => Math.floor(Math.random() * 16).toString(16)).join('');
+export const generateExternalId = () => Array.from({ length: 16 })
+    .map(() => Math.floor(Math.random() * 16).toString(16))
+    .join('');
 export class StorageService {
     providerClient;
     logger;
@@ -38,7 +40,7 @@ export class StorageService {
             const { data, error } = await this.providerClient.POST('/api/storages', {
                 body: storage,
             });
-            if (error && error.message) {
+            if (error?.message) {
                 this.logger.error({ err: error }, 'Failed to create storage');
                 throw new StorageCreateError(error.message);
             }
@@ -51,12 +53,16 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Storage creation failed');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
     async download(params, progressCb) {
-        const resourceFile = await readJsonFile({ path: params.resourcePath });
+        const resourceFile = await readJsonFile({
+            path: params.resourcePath,
+        });
         if (!Value.Check(StorageResourceSchema, resourceFile)) {
             throw new StorageError('Invalid resource file format, please verify resource.json against the schema.');
         }
@@ -90,7 +96,7 @@ export class StorageService {
     async getCentralizedStorage() {
         try {
             const storages = await this.requestStorages();
-            const centralized = storages.find(storage => storage.isCentralized);
+            const centralized = storages.find((storage) => storage.isCentralized);
             if (!centralized) {
                 const storage = await this.initCentralizedStorage();
                 return storage;
@@ -114,7 +120,7 @@ export class StorageService {
             }
             const { activeStorageId } = data || {};
             const storages = await this.requestStorages();
-            const storage = storages.find(storage => storage.id === activeStorageId);
+            const storage = storages.find((storage) => storage.id === activeStorageId);
             if (!storage) {
                 throw new StorageError('Selected storage not found please select storage first');
             }
@@ -122,7 +128,9 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Failed to get current storage');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
@@ -146,7 +154,9 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Storage initialization failed');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
@@ -167,7 +177,9 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Storage initialization failed');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
@@ -190,7 +202,9 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Failed to request storages');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
@@ -219,7 +233,9 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error }, 'Failed to save selected storage');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
@@ -243,13 +259,17 @@ export class StorageService {
         }
         catch (error) {
             this.logger.error({ err: error, storageId: id }, 'Failed to update storage');
-            const error_ = error instanceof StorageError ? error : new ProviderClientError('Request failed please try again later');
+            const error_ = error instanceof StorageError
+                ? error
+                : new ProviderClientError('Request failed please try again later');
             throw error_;
         }
     }
     async upload(params, progressCb) {
         const storage = await this.getCurrentStorage();
-        const remotePath = params.remotePath ? params.remotePath.replaceAll('..', '').replace(/^\/+/, '') : generateExternalId();
+        const remotePath = params.remotePath
+            ? params.remotePath.replaceAll('..', '').replace(/^\/+/, '')
+            : generateExternalId();
         const resourceFilePath = preparePath(params.outputPath ?? 'resource.json');
         try {
             await fs.stat(resourceFilePath);
@@ -262,7 +282,9 @@ export class StorageService {
         }
         let metadata = {};
         if (params.metadataPath) {
-            metadata = await readJsonFile({ path: preparePath(params.metadataPath) });
+            metadata = await readJsonFile({
+                path: preparePath(params.metadataPath),
+            });
         }
         const { readCredentials, writeCredentials } = this.getStorageCredentials(storage, remotePath);
         const info = await fs.stat(params.localPath);
@@ -315,7 +337,8 @@ export class StorageService {
                     bucket: storage.bucket,
                     prefix: joinPaths(storage.prefix, remotePath),
                     token: readAccessToken,
-                }, writeCredentials: {
+                },
+                writeCredentials: {
                     bucket: storage.bucket,
                     prefix: joinPaths(storage.prefix, remotePath),
                     token: writeAccessToken,
@@ -334,7 +357,8 @@ export class StorageService {
                     endpoint: S3_ENDPOINT,
                     prefix: joinPaths(storage.prefix, remotePath),
                     secretKey: readSecretAccessKey,
-                }, writeCredentials: {
+                },
+                writeCredentials: {
                     accessKeyId: writeAccessKeyId,
                     bucket: storage.bucket,
                     endpoint: S3_ENDPOINT,
@@ -347,5 +371,8 @@ export class StorageService {
     }
 }
 __decorate([
-    Retryable({ maxAttempts: 3, value: [StoragesUndefinedError, StorageCreateError, ProviderClientError] })
+    Retryable({
+        maxAttempts: 3,
+        value: [StoragesUndefinedError, StorageCreateError, ProviderClientError],
+    })
 ], StorageService.prototype, "getCentralizedStorage", null);

package/dist/utils/helper.d.ts

@@ -1,4 +1,5 @@
 export declare const getConfigName: (name: string) => string;
+export declare const getConfigNameFromCredentials: (privateKey: string, url: string) => string;
 export declare const preparePath: (rawPath: string) => string;
 export declare const joinPaths: (...args: string[]) => string;
 export type ReadJsonFileParams = {

package/dist/utils/helper.js

@@ -1,7 +1,21 @@
+import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
-export const getConfigName = (name) => name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-') + '.config.json';
+export const getConfigName = (name) => `${name.toLowerCase().replaceAll(/[^a-z0-9]+/g, '-')}.config.json`;
+export const getConfigNameFromCredentials = (privateKey, url) => {
+    const normalizedKey = privateKey.trim();
+    const normalizedUrl = url.trim();
+    if (!normalizedKey || !normalizedUrl) {
+        throw new Error('Private key and URL must not be empty');
+    }
+    const hashBuilder = createHash('sha256');
+    hashBuilder.update(normalizedKey);
+    hashBuilder.update('|');
+    hashBuilder.update(normalizedUrl);
+    const hash = hashBuilder.digest('hex');
+    return `${hash}.config.json`;
+};
 export const preparePath = (rawPath) => {
     if (path.isAbsolute(rawPath))
         return rawPath;

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 {};