@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/prompts/personalAccessKeyPrompt.js

@@ -0,0 +1,135 @@
+import open from 'open';
+import { OAUTH_SCOPES, DEFAULT_OAUTH_SCOPES, } from '@hubspot/local-dev-lib/constants/auth';
+import { deleteConfigFileIfEmpty } from '@hubspot/local-dev-lib/config';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { uiLogger } from '../ui/logger.js';
+import { promptUser } from './promptUtils.js';
+import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
+import { uiInfoSection } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+/**
+ * Displays notification to user that we are about to open the browser,
+ * then opens their browser to the personal-access-key shortlink
+ */
+export async function personalAccessKeyPrompt({ env, account, }) {
+    const websiteOrigin = getHubSpotWebsiteOrigin(env);
+    let url = `${websiteOrigin}/l/personal-access-key`;
+    if (process.env.BROWSER !== 'none') {
+        uiInfoSection(lib.prompts.personalAccessKeyPrompt.personalAccessKeySetupTitle, () => {
+            uiLogger.log(lib.prompts.personalAccessKeyPrompt.personalAccessKeyBrowserOpenPrep);
+        });
+        if (account) {
+            url = `${websiteOrigin}/personal-access-key/${account}`;
+        }
+        const { personalAccessKeyBrowserOpenPrep: choice } = await promptUser([
+            PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP,
+        ]);
+        if (!choice) {
+            deleteConfigFileIfEmpty();
+            throw new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS);
+        }
+        if (choice ===
+            lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
+                .OPEN_BROWSER) {
+            open(url, { url: true });
+            uiLogger.log(lib.prompts.personalAccessKeyPrompt.logs.openingWebBrowser(url));
+        }
+    }
+    const { personalAccessKey } = await promptUser(PERSONAL_ACCESS_KEY);
+    return {
+        personalAccessKey,
+        env,
+    };
+}
+const ACCOUNT_ID = {
+    name: 'accountId',
+    message: lib.prompts.personalAccessKeyPrompt.enterAccountId,
+    type: 'number',
+    validate(val) {
+        if (!Number.isNaN(val) && val !== undefined && val > 0) {
+            return true;
+        }
+        return lib.prompts.personalAccessKeyPrompt.errors.invalidAccountId;
+    },
+};
+const CLIENT_ID = {
+    name: 'clientId',
+    message: lib.prompts.personalAccessKeyPrompt.enterClientId,
+    validate(val) {
+        if (typeof val !== 'string') {
+            return lib.prompts.personalAccessKeyPrompt.errors.invalidOauthClientId;
+        }
+        else if (val.length !== 36) {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidOauthClientIdLength;
+        }
+        return true;
+    },
+};
+const CLIENT_SECRET = {
+    name: 'clientSecret',
+    message: lib.prompts.personalAccessKeyPrompt.enterClientSecret,
+    validate(val) {
+        if (typeof val !== 'string') {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidOauthClientSecret;
+        }
+        else if (val.length !== 36) {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidOauthClientSecretLength;
+        }
+        else if (val[0] === '*') {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidOauthClientSecretCopy;
+        }
+        return true;
+    },
+};
+const PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP = {
+    name: 'personalAccessKeyBrowserOpenPrep',
+    type: 'list',
+    message: 'Choose your preferred method of authentication',
+    choices: Object.values(lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices),
+    default: lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
+        .OPEN_BROWSER,
+};
+const PERSONAL_ACCESS_KEY = {
+    name: 'personalAccessKey',
+    message: lib.prompts.personalAccessKeyPrompt.enterPersonalAccessKey,
+    transformer: (val) => {
+        if (!val)
+            return val;
+        let res = '';
+        for (let i = 0; i < val.length; i++) {
+            res += '*';
+        }
+        return res;
+    },
+    validate(val) {
+        if (!val || typeof val !== 'string') {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidPersonalAccessKey;
+        }
+        else if (val[0] === '•') {
+            return lib.prompts.personalAccessKeyPrompt.errors
+                .invalidPersonalAccessKeyCopy;
+        }
+        return true;
+    },
+};
+const SCOPES = {
+    type: 'checkbox',
+    name: 'scopes',
+    message: lib.prompts.personalAccessKeyPrompt.selectScopes,
+    default: [...DEFAULT_OAUTH_SCOPES],
+    choices: [...OAUTH_SCOPES],
+};
+export const OAUTH_FLOW = [
+    getCliAccountNamePromptConfig(),
+    ACCOUNT_ID,
+    CLIENT_ID,
+    CLIENT_SECRET,
+    SCOPES,
+];

package/lib/prompts/previewPrompt.d.ts

@@ -0,0 +1,15 @@
+type PreviewPromptResponse = {
+    src: string;
+    dest: string;
+};
+type PreviewProjectPromptResponse = {
+    themeComponentPath: string;
+};
+export declare function previewPrompt(promptOptions?: {
+    src?: string;
+    dest?: string;
+}): Promise<PreviewPromptResponse>;
+export declare function previewProjectPrompt(themeComponents: {
+    path: string;
+}[]): Promise<PreviewProjectPromptResponse>;
+export {};

package/lib/prompts/previewPrompt.js

@@ -0,0 +1,48 @@
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function previewPrompt(promptOptions = {}) {
+    return promptUser([
+        {
+            name: 'src',
+            message: lib.prompts.previewPrompt.enterSrc,
+            when: !promptOptions.src,
+            default: '.',
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.previewPrompt.errors.srcRequired;
+                }
+                return true;
+            },
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.previewPrompt.enterDest,
+            when: !promptOptions.dest,
+            default: path.basename(getCwd()),
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.previewPrompt.errors.destRequired;
+                }
+                return true;
+            },
+        },
+    ]);
+}
+export async function previewProjectPrompt(themeComponents) {
+    return promptUser([
+        {
+            name: 'themeComponentPath',
+            message: lib.prompts.previewPrompt.themeProjectSelect,
+            type: 'list',
+            choices: themeComponents.map(t => {
+                const themeName = path.basename(t.path);
+                return {
+                    name: themeName,
+                    value: t.path,
+                };
+            }),
+        },
+    ]);
+}

package/lib/prompts/projectAddPrompt.d.ts

@@ -0,0 +1,15 @@
+import { Separator } from '@inquirer/prompts';
+import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects.js';
+type ProjectAddPromptResponse = {
+    componentTemplate: ComponentTemplate;
+    name: string;
+};
+type ProjectAddPromptResponseV2 = {
+    componentTemplate: ComponentTemplate[];
+};
+export declare function projectAddPrompt(components: ComponentTemplate[], promptOptions?: {
+    name?: string;
+    type?: string;
+}): Promise<ProjectAddPromptResponse>;
+export declare function projectAddPromptV2(components: (ComponentTemplateChoice | Separator)[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV2>;
+export {};

package/lib/prompts/projectAddPrompt.js

@@ -0,0 +1,82 @@
+import { Separator } from '@inquirer/prompts';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+function findComponentByPathOrLabel(components, componentPathOrLabel) {
+    return components.find(c => c.path === componentPathOrLabel || c.label === componentPathOrLabel);
+}
+export async function projectAddPrompt(components, promptOptions = {}) {
+    const providedTypeIsValid = !!promptOptions.type &&
+        !!findComponentByPathOrLabel(components, promptOptions.type);
+    const result = await promptUser([
+        {
+            name: 'componentTemplate',
+            message: () => {
+                return promptOptions.type && !providedTypeIsValid
+                    ? lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
+                    : lib.prompts.projectAddPrompt.selectType;
+            },
+            when: !providedTypeIsValid,
+            type: 'list',
+            choices: components.map(type => {
+                return {
+                    name: type.label,
+                    value: type,
+                };
+            }),
+        },
+        {
+            name: 'name',
+            message: lib.prompts.projectAddPrompt.enterName,
+            when: !promptOptions.name,
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.projectAddPrompt.errors.nameRequired;
+                }
+                return true;
+            },
+        },
+    ]);
+    if (!result.name) {
+        result.name = promptOptions.name;
+    }
+    if (providedTypeIsValid) {
+        result.componentTemplate = findComponentByPathOrLabel(components, promptOptions.type);
+    }
+    return result;
+}
+export async function projectAddPromptV2(components, selectedFeatures) {
+    const selectedComponents = [];
+    if (selectedFeatures) {
+        components.forEach(template => {
+            if (template instanceof Separator || !template.value) {
+                return;
+            }
+            if (selectedFeatures?.includes(template.value.cliSelector || template.value.type)) {
+                if (template.disabled) {
+                    throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
+    if (!components?.length) {
+        uiLogger.error(lib.prompts.projectAddPrompt.errors.noSelectableChoices);
+        uiLogger.log('');
+        return { componentTemplate: [] };
+    }
+    const result = await promptUser([
+        {
+            name: 'componentTemplate',
+            message: lib.prompts.projectAddPrompt.selectFeatures,
+            when: !selectedFeatures && selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: components,
+            pageSize: components.length,
+        },
+    ]);
+    if (!result.componentTemplate) {
+        result.componentTemplate = selectedComponents;
+    }
+    return result;
+}

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -0,0 +1,12 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
+export type ProjectDevTargetAccountPromptResponse = {
+    targetAccountId: number | null;
+    createNestedAccount: boolean;
+    parentAccountId?: number | null;
+    notInConfigAccount?: DeveloperTestAccount | null;
+};
+export declare function selectSandboxTargetAccountPrompt(accounts: HubSpotConfigAccount[], defaultAccountConfig: HubSpotConfigAccount): Promise<ProjectDevTargetAccountPromptResponse>;
+export declare function selectDeveloperTestTargetAccountPrompt(accounts: HubSpotConfigAccount[], defaultAccountConfig: HubSpotConfigAccount): Promise<ProjectDevTargetAccountPromptResponse>;
+export declare function confirmDefaultAccountPrompt(accountName: string, accountType: string): Promise<boolean>;
+export declare function confirmUseExistingDeveloperTestAccountPrompt(account: DeveloperTestAccount): Promise<boolean>;

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -0,0 +1,166 @@
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { isSandbox } from '../accountTypes.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+function mapNestedAccount(accountConfig) {
+    const parentAccountId = accountConfig.parentAccountId ?? null;
+    return {
+        name: uiAccountDescription(accountConfig.accountId, false),
+        value: {
+            targetAccountId: accountConfig.accountId,
+            createNestedAccount: false,
+            parentAccountId,
+        },
+    };
+}
+function getNonConfigDeveloperTestAccountName(account) {
+    return `${account.accountName} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
+}
+export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
+    let choices = [];
+    let sandboxUsage = {
+        STANDARD: { used: 0, available: 0, limit: 0 },
+        DEVELOPER: { used: 0, available: 0, limit: 0 },
+    };
+    try {
+        const { data } = await getSandboxUsageLimits(defaultAccountId);
+        sandboxUsage = data.usage;
+    }
+    catch (err) {
+        uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
+    }
+    const sandboxAccounts = accounts
+        .reverse()
+        .filter(config => isSandbox(config) && config.parentAccountId === defaultAccountId);
+    let disabledMessage = false;
+    if (sandboxUsage['DEVELOPER'] && sandboxUsage['DEVELOPER'].available === 0) {
+        if (sandboxAccounts.length < sandboxUsage['DEVELOPER'].limit) {
+            disabledMessage =
+                lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion(sandboxUsage['DEVELOPER'].limit);
+        }
+        else {
+            disabledMessage = lib.prompts.projectDevTargetAccountPrompt.sandboxLimit(sandboxUsage['DEVELOPER'].limit);
+        }
+    }
+    // Order choices by Developer Sandbox -> Standard Sandbox
+    choices = [
+        ...sandboxAccounts
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
+            .map(mapNestedAccount),
+        ...sandboxAccounts
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
+            .map(mapNestedAccount),
+        {
+            name: lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption,
+            value: {
+                targetAccountId: null,
+                createNestedAccount: true,
+            },
+            disabled: disabledMessage,
+        },
+        {
+            name: lib.prompts.projectDevTargetAccountPrompt
+                .chooseDefaultAccountOption,
+            value: {
+                targetAccountId: defaultAccountId,
+                createNestedAccount: false,
+            },
+        },
+    ];
+    return selectTargetAccountPrompt(defaultAccountId, 'sandbox account', choices);
+}
+export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
+    let devTestAccountsResponse;
+    try {
+        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
+        devTestAccountsResponse = data;
+    }
+    catch (err) {
+        uiLogger.debug('Unable to fetch developer test account usage limits: ', err);
+    }
+    let disabledMessage = false;
+    if (devTestAccountsResponse &&
+        devTestAccountsResponse.results.length >=
+            devTestAccountsResponse.maxTestPortals) {
+        disabledMessage =
+            lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit(devTestAccountsResponse.maxTestPortals);
+    }
+    const devTestAccounts = [];
+    if (devTestAccountsResponse && devTestAccountsResponse.results) {
+        const accountIds = accounts.map(account => account.accountId);
+        devTestAccountsResponse.results.forEach(acct => {
+            const inConfig = accountIds.includes(acct.id);
+            devTestAccounts.push({
+                name: getNonConfigDeveloperTestAccountName(acct),
+                value: {
+                    targetAccountId: acct.id,
+                    createNestedAccount: false,
+                    parentAccountId: defaultAccountId ?? null,
+                    notInConfigAccount: inConfig ? null : acct,
+                },
+            });
+        });
+    }
+    const choices = [
+        ...devTestAccounts,
+        {
+            name: lib.prompts.projectDevTargetAccountPrompt
+                .createNewDeveloperTestAccountOption,
+            value: {
+                targetAccountId: null,
+                createNestedAccount: true,
+            },
+            disabled: disabledMessage,
+        },
+    ];
+    return selectTargetAccountPrompt(defaultAccountId, HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
+}
+async function selectTargetAccountPrompt(defaultAccountId, accountType, choices) {
+    const accountId = defaultAccountId;
+    const { targetAccountInfo } = await promptUser([
+        {
+            name: 'targetAccountInfo',
+            type: 'list',
+            message: lib.prompts.projectDevTargetAccountPrompt.promptMessage(accountType, uiAccountDescription(accountId)),
+            choices,
+            loop: false,
+        },
+    ]);
+    return targetAccountInfo;
+}
+export async function confirmDefaultAccountPrompt(accountName, accountType) {
+    const { useDefaultAccount } = await promptUser([
+        {
+            name: 'useDefaultAccount',
+            type: 'confirm',
+            message: lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount(accountName, accountType),
+        },
+    ]);
+    return useDefaultAccount;
+}
+export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
+    const { confirmUseExistingDeveloperTestAccount } = await promptUser([
+        {
+            name: 'confirmUseExistingDeveloperTestAccount',
+            type: 'confirm',
+            message: lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount(getNonConfigDeveloperTestAccountName(account)),
+        },
+    ]);
+    return confirmUseExistingDeveloperTestAccount;
+}

package/lib/prompts/projectNameAndDestPrompt.d.ts

@@ -0,0 +1,3 @@
+import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt.js';
+export declare function projectNameAndDestPrompt(promptOptions: PromptOptionsArg): Promise<ProjectNameAndDestPromptResponse>;
+export declare function validateProjectDirectory(input?: string): string | boolean;

package/lib/prompts/projectNameAndDestPrompt.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import { sanitizeFileName, getCwd, untildify, isValidPath, } from '@hubspot/local-dev-lib/path';
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+export async function projectNameAndDestPrompt(promptOptions) {
+    const result = await promptUser([
+        {
+            name: 'name',
+            message: lib.prompts.projectNameAndDestPrompt.enterName,
+            when: !promptOptions.name,
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
+                }
+                return true;
+            },
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.projectNameAndDestPrompt.enterDest,
+            when: !promptOptions.dest,
+            default: (answers) => {
+                const projectName = sanitizeFileName(promptOptions.name || answers.name);
+                return path.resolve(getCwd(), projectName);
+            },
+            validate: validateProjectDirectory,
+            filter: (input) => {
+                return untildify(input);
+            },
+        },
+    ]);
+    if (!result.name) {
+        result.name = promptOptions.name;
+    }
+    if (!result.dest) {
+        result.dest = promptOptions.dest;
+    }
+    return result;
+}
+export function validateProjectDirectory(input) {
+    if (!input) {
+        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
+    }
+    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
+    }
+    if (!isValidPath(input)) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
+    }
+    return true;
+}

package/lib/prompts/projectNamePrompt.d.ts

@@ -0,0 +1,6 @@
+export type ProjectNamePromptResponse = {
+    projectName: string;
+};
+export declare function projectNamePrompt(accountId: number, options?: {
+    project?: string;
+}): Promise<ProjectNamePromptResponse>;

package/lib/prompts/projectNamePrompt.js

@@ -0,0 +1,27 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+export async function projectNamePrompt(accountId, options = {}) {
+    const result = await promptUser({
+        name: 'projectName',
+        message: lib.prompts.projectNamePrompt.enterName,
+        when: !options.project,
+        validate: async (val) => {
+            if (typeof val !== 'string' || !val) {
+                return lib.prompts.projectNamePrompt.errors.invalidName;
+            }
+            const { projectExists } = await ensureProjectExists(accountId, val, {
+                allowCreate: false,
+                noLogs: true,
+            });
+            if (!projectExists) {
+                return lib.prompts.projectNamePrompt.errors.projectDoesNotExist(val, accountId);
+            }
+            return true;
+        },
+    });
+    if (!result.projectName && options.project) {
+        result.projectName = options.project;
+    }
+    return result;
+}

package/lib/prompts/projectsLogsPrompt.d.ts

@@ -0,0 +1,12 @@
+type ProjectLogsPromptOptions = {
+    functionChoices?: string[];
+    promptOptions?: {
+        function?: string;
+    };
+    projectName?: string;
+};
+type ProjectLogsPromptResponse = {
+    functionName?: string;
+};
+export declare function projectLogsPrompt({ functionChoices, promptOptions, projectName, }: ProjectLogsPromptOptions): Promise<ProjectLogsPromptResponse>;
+export {};

package/lib/prompts/projectsLogsPrompt.js

@@ -0,0 +1,20 @@
+import { lib } from '../../lang/en.js';
+import { promptUser } from './promptUtils.js';
+export async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
+    if (!functionChoices) {
+        return {};
+    }
+    if (functionChoices.length === 1) {
+        return { functionName: functionChoices[0] };
+    }
+    return promptUser([
+        {
+            name: 'functionName',
+            type: 'list',
+            message: lib.prompts.projectLogsPrompt.functionName(projectName),
+            when: () => (!promptOptions || !promptOptions.function) &&
+                functionChoices.length > 0,
+            choices: functionChoices,
+        },
+    ]);
+}

package/lib/prompts/promptUtils.d.ts

@@ -0,0 +1,32 @@
+import { Separator as _Separator } from '@inquirer/prompts';
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
+export declare const Separator: _Separator;
+export declare const PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+};
+export declare const CHECKBOX_PROMPT_THEME: {
+    prefix: {
+        idle: string;
+    };
+    style: {
+        disabledChoice: (text: string) => string;
+    };
+};
+export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
+export declare function confirmPrompt(message: string, options?: {
+    defaultAnswer?: boolean;
+}): Promise<boolean>;
+export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, loop, }: {
+    choices: PromptChoices<T>;
+    when?: PromptWhen;
+    defaultAnswer?: string | number | boolean;
+    validate?: (input: T[]) => (boolean | string) | Promise<boolean | string>;
+    loop?: boolean;
+}): Promise<T>;
+export declare function inputPrompt(message: string, { when, validate, defaultAnswer, }?: {
+    when?: boolean | (() => boolean);
+    validate?: (input: string) => (boolean | string) | Promise<boolean | string>;
+    defaultAnswer?: string;
+}): Promise<string>;