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

package/lib/prompts/promptUtils.js

@@ -0,0 +1,222 @@
+import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import chalk from 'chalk';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export const Separator = new _Separator();
+export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
+export const CHECKBOX_PROMPT_THEME = {
+    prefix: { idle: chalk.green('?') },
+    style: {
+        disabledChoice: (text) => chalk.dim(` ◯ ${text}`),
+    },
+};
+function isUserCancellationError(error) {
+    return error instanceof Error && error.name === 'ExitPromptError';
+}
+function isNoSelectableChoicesError(error) {
+    return (error instanceof Error && error.message?.includes('No selectable choices'));
+}
+function handlePromptError(config, error) {
+    if (isUserCancellationError(error)) {
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    if (isNoSelectableChoicesError(error)) {
+        if (!Array.isArray(config)) {
+            uiLogger.log(config.message);
+        }
+        uiLogger.error(lib.prompts.promptUtils.errors.noSelectableChoices);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    throw error;
+}
+function mapPromptChoicesToChoices(choices) {
+    return (choices?.map(choice => {
+        if (typeof choice === 'string') {
+            return { value: choice, name: choice };
+        }
+        else if (choice instanceof _Separator) {
+            return choice;
+        }
+        return {
+            value: choice.value,
+            name: choice.name,
+            disabled: choice.disabled,
+            checked: choice.checked,
+        };
+    }) || []);
+}
+async function handleArrayConfig(config) {
+    const result = {};
+    for (const prompt of config) {
+        if (prompt.when !== undefined) {
+            const shouldPrompt = typeof prompt.when === 'function'
+                ? prompt.when()
+                : (prompt.when ?? true);
+            if (!shouldPrompt) {
+                continue;
+            }
+        }
+        if (typeof prompt.message === 'function') {
+            prompt.message = prompt.message(result);
+        }
+        // Pass the accumulated results to each prompt
+        const promptWithAnswers = {
+            ...prompt,
+            default: typeof prompt.default === 'function'
+                ? (answers) => {
+                    const mergedAnswers = { ...answers, ...result };
+                    return prompt.default(mergedAnswers);
+                }
+                : prompt.default,
+        };
+        const response = await promptUser(promptWithAnswers);
+        Object.assign(result, response);
+    }
+    return result;
+}
+export async function promptUser(config) {
+    try {
+        if (Array.isArray(config)) {
+            return await handleArrayConfig(config);
+        }
+        else {
+            if (config.when !== undefined) {
+                const shouldPrompt = typeof config.when === 'function'
+                    ? config.when()
+                    : (config.when ?? true);
+                if (!shouldPrompt) {
+                    return Promise.resolve({});
+                }
+            }
+        }
+        switch (config.type) {
+            case 'list':
+                return await handleSelectPrompt(config);
+            case 'input':
+                return await handleInputPrompt(config);
+            case 'confirm':
+                return await handleConfirmPrompt(config);
+            case 'checkbox':
+                return await handleCheckboxPrompt(config);
+            case 'password':
+                return await handlePasswordPrompt(config);
+            case 'number':
+                return await handleNumberPrompt(config);
+            case 'rawlist':
+                return await handleRawListPrompt(config);
+            default:
+                return await handleInputPrompt(config);
+        }
+    }
+    catch (error) {
+        handlePromptError(config, error);
+    }
+}
+function handleRawListPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    choices.map((choice, index) => {
+        if (!(choice instanceof _Separator)) {
+            choice.name = `${index + 1}) ${choice.name}`;
+        }
+    });
+    return select({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        default: config.default,
+        loop: config.loop,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleNumberPrompt(config) {
+    return number({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handlePasswordPrompt(config) {
+    return password({
+        message: config.message,
+        mask: '*',
+        validate: config.validate,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleCheckboxPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return checkbox({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        validate: config.validate,
+        loop: config.loop,
+        theme: CHECKBOX_PROMPT_THEME,
+        shortcuts: {
+            invert: null,
+        },
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleConfirmPrompt(config) {
+    return confirm({
+        message: config.message,
+        default: config.default,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleInputPrompt(config) {
+    return input({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        transformer: config.transformer,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleSelectPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return select({
+        message: config.message,
+        choices: choices,
+        default: config.default,
+        pageSize: config.pageSize,
+        loop: config.loop,
+        theme: PROMPT_THEME,
+    }).then(resp => ({ [config.name]: resp }));
+}
+export async function confirmPrompt(message, options = {}) {
+    const { defaultAnswer = true } = options;
+    const { confirm: result } = await promptUser({
+        name: 'confirm',
+        type: 'confirm',
+        message,
+        default: defaultAnswer,
+    });
+    return result;
+}
+export async function listPrompt(message, { choices, when, defaultAnswer, validate, loop, }) {
+    const { choice } = await promptUser({
+        name: 'choice',
+        type: 'list',
+        message,
+        choices,
+        when,
+        default: defaultAnswer,
+        validate,
+        loop,
+    });
+    return choice;
+}
+export async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
+    const { input } = await promptUser({
+        name: 'input',
+        type: 'input',
+        default: defaultAnswer,
+        message,
+        when,
+        validate,
+    });
+    return input;
+}

package/lib/prompts/sandboxesPrompt.d.ts

@@ -0,0 +1,10 @@
+import { SandboxAccountType } from '../../types/Sandboxes.js';
+type SandboxTypePromptResponse = {
+    type: SandboxAccountType;
+};
+type DeleteSandboxPromptResponse = {
+    account: string;
+};
+export declare function sandboxTypePrompt(): Promise<SandboxTypePromptResponse>;
+export declare function deleteSandboxPrompt(promptParentAccount?: boolean): Promise<DeleteSandboxPromptResponse | undefined>;
+export {};

package/lib/prompts/sandboxesPrompt.js

@@ -0,0 +1,63 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { isSandbox } from '../accountTypes.js';
+import { getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+function mapSandboxAccountChoices(portals) {
+    return (portals
+        ?.filter(p => isSandbox(p))
+        .map(p => ({
+        name: uiAccountDescription(p.accountId, false),
+        value: p.accountId,
+    })) || []);
+}
+function mapNonSandboxAccountChoices(portals) {
+    return (portals
+        ?.filter(p => !isSandbox(p))
+        .map(p => ({
+        name: `${p.name} (${p.accountId})`,
+        value: p.accountId,
+    })) || []);
+}
+export async function sandboxTypePrompt() {
+    return promptUser([
+        {
+            name: 'type',
+            message: lib.prompts.sandboxesPrompt.type.message,
+            type: 'list',
+            choices: [
+                {
+                    name: lib.prompts.sandboxesPrompt.type.developer,
+                    value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                },
+                {
+                    name: lib.prompts.sandboxesPrompt.type.standard,
+                    value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                },
+            ],
+            default: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        },
+    ]);
+}
+export function deleteSandboxPrompt(promptParentAccount = false) {
+    const accountsList = getAllConfigAccounts();
+    const choices = promptParentAccount
+        ? mapNonSandboxAccountChoices(accountsList)
+        : mapSandboxAccountChoices(accountsList);
+    if (!choices.length) {
+        return Promise.resolve(undefined);
+    }
+    return promptUser([
+        {
+            name: 'account',
+            message: promptParentAccount
+                ? lib.prompts.sandboxesPrompt.selectParentAccountName
+                : lib.prompts.sandboxesPrompt.selectAccountName,
+            type: 'list',
+            pageSize: 20,
+            choices,
+            default: getConfigDefaultAccountIfExists()?.accountId,
+        },
+    ]);
+}

package/lib/prompts/secretPrompt.d.ts

@@ -0,0 +1,13 @@
+type SecretValuePromptResponse = {
+    secretValue: string;
+};
+export declare function secretValuePrompt(): Promise<SecretValuePromptResponse>;
+type SecretNamePromptResponse = {
+    secretName: string;
+};
+export declare function secretNamePrompt(): Promise<SecretNamePromptResponse>;
+type SecretListPromptResponse = {
+    secretToModify: string;
+};
+export declare function secretListPrompt(secrets: string[], message: string): Promise<SecretListPromptResponse>;
+export {};

package/lib/prompts/secretPrompt.js

@@ -0,0 +1,31 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export function secretValuePrompt() {
+    return promptUser([
+        {
+            name: 'secretValue',
+            type: 'password',
+            mask: '*',
+            message: lib.prompts.secretPrompt.enterValue,
+        },
+    ]);
+}
+export function secretNamePrompt() {
+    return promptUser([
+        {
+            name: 'secretName',
+            type: 'input',
+            message: lib.prompts.secretPrompt.enterName,
+        },
+    ]);
+}
+export function secretListPrompt(secrets, message) {
+    return promptUser([
+        {
+            name: 'secretToModify',
+            type: 'list',
+            choices: secrets,
+            message,
+        },
+    ]);
+}

package/lib/prompts/selectAppPrompt.d.ts

@@ -0,0 +1,2 @@
+import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
+export declare function selectAppPrompt(accountId: number, appId?: number): Promise<PublicApp | null>;

package/lib/prompts/selectAppPrompt.js

@@ -0,0 +1,37 @@
+import { uiLogger } from '../ui/logger.js';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { debugError } from '../errorHandlers/index.js';
+import { lib } from '../../lang/en.js';
+import { listPrompt } from '../prompts/promptUtils.js';
+export async function selectAppPrompt(accountId, appId) {
+    let availableApps = [];
+    try {
+        const appsResponse = await fetchPublicAppsForPortal(accountId);
+        if (appsResponse.data.results) {
+            availableApps = appsResponse.data.results;
+        }
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (availableApps.length === 0) {
+        uiLogger.error(lib.prompts.selectAppPrompt.errors.noApps);
+        return null;
+    }
+    if (appId) {
+        const targetApp = availableApps.find(app => app.id === appId);
+        if (targetApp) {
+            return targetApp;
+        }
+        else {
+            uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
+        }
+    }
+    const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {
+        choices: availableApps.map(app => ({
+            name: `${app.name} (${app.id})`,
+            value: app,
+        })),
+    });
+    return appPromptValue;
+}

package/lib/prompts/selectHubDBTablePrompt.d.ts

@@ -0,0 +1,12 @@
+export declare function selectHubDBTablePrompt({ accountId, options, skipDestPrompt, }: {
+    accountId: number;
+    options: {
+        tableId?: number;
+        dest?: string;
+    };
+    skipDestPrompt?: boolean;
+}): Promise<{
+    tableId: any;
+} & {
+    dest: any;
+}>;

package/lib/prompts/selectHubDBTablePrompt.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
+import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+async function fetchHubDBOptions(accountId) {
+    try {
+        const { data: { results: tables }, } = await fetchTables(accountId);
+        if (tables.length === 0) {
+            uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
+        }
+        return tables;
+    }
+    catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
+        debugError(error, { accountId });
+        uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
+    }
+}
+export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
+    const hubdbTables = await fetchHubDBOptions(accountId);
+    const id = options.tableId?.toString();
+    const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
+    return promptUser([
+        {
+            name: 'tableId',
+            message: lib.prompts.selectHubDBTablePrompt.selectTable,
+            when: !id && !isValidTable,
+            type: 'list',
+            choices: hubdbTables.map(table => {
+                return {
+                    name: `${table.label} (${table.id})`,
+                    value: table.id,
+                };
+            }),
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.selectHubDBTablePrompt.enterDest,
+            when: !options.dest && !skipDestPrompt,
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.destRequired;
+                }
+                if (fs.existsSync(input)) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidDest;
+                }
+                if (!isValidPath(input)) {
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters;
+                }
+                return true;
+            },
+            filter: (input) => {
+                return untildify(input);
+            },
+        },
+    ]);
+}

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -0,0 +1,27 @@
+import { Separator } from '@inquirer/prompts';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects.js';
+export type SelectProjectTemplatePromptResponse = {
+    projectTemplate?: ProjectTemplate;
+    componentTemplates?: ComponentTemplate[];
+};
+type SelectProjectTemplatePromptResponseProjectTemplate = {
+    projectTemplate: ProjectTemplate;
+    componentTemplates: undefined;
+};
+type SelectProjectTemplatePromptResponseComponentTemplates = {
+    projectTemplate?: undefined;
+    componentTemplates?: ComponentTemplate[];
+};
+export type ProjectNameAndDestPromptResponse = {
+    name: string;
+    dest: string;
+};
+export type PromptOptionsArg = {
+    name?: string;
+    dest?: string;
+    template?: string;
+    features?: string[];
+};
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<SelectProjectTemplatePromptResponseProjectTemplate>;
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: (ComponentTemplateChoice | Separator)[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
+export {};

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -0,0 +1,75 @@
+import { Separator } from '@inquirer/prompts';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
+    return projectTemplates.find(t => t.name === templateNameOrLabel || t.label === templateNameOrLabel);
+}
+export async function selectProjectTemplatePrompt(promptOptions, projectTemplates, componentTemplates) {
+    const createProjectFromTemplate = !!projectTemplates && projectTemplates.length > 0;
+    const createProjectFromComponents = Array.isArray(componentTemplates) && componentTemplates?.length > 0;
+    const selectedComponents = [];
+    if (createProjectFromComponents && promptOptions.features) {
+        componentTemplates.forEach(template => {
+            if (template instanceof Separator || !template.value) {
+                return;
+            }
+            if (promptOptions.features?.includes(template.value.cliSelector || template.value.type)) {
+                if (template.disabled) {
+                    throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
+                }
+                selectedComponents.push(template.value);
+            }
+        });
+    }
+    const providedTemplateIsValid = createProjectFromTemplate &&
+        !!promptOptions.template &&
+        !!findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
+    const result = await promptUser([
+        {
+            name: 'projectTemplate',
+            message: () => {
+                return promptOptions.template && !providedTemplateIsValid
+                    ? lib.prompts.selectProjectTemplatePrompt.errors.invalidTemplate(promptOptions.template)
+                    : lib.prompts.selectProjectTemplatePrompt.selectTemplate;
+            },
+            when: createProjectFromTemplate && !providedTemplateIsValid,
+            type: 'list',
+            choices: createProjectFromTemplate
+                ? projectTemplates.map(template => {
+                    return {
+                        name: template.label,
+                        value: template,
+                    };
+                })
+                : undefined,
+        },
+        {
+            name: 'componentTemplates',
+            message: lib.prompts.selectProjectTemplatePrompt.features,
+            when: !promptOptions.features &&
+                createProjectFromComponents &&
+                selectedComponents.length === 0,
+            type: 'checkbox',
+            choices: componentTemplates,
+            loop: false,
+            pageSize: componentTemplates?.length,
+        },
+    ]);
+    if (result.componentTemplates?.length === 0) {
+        uiLogger.log(lib.projects.add.nothingAdded);
+    }
+    if (!result.componentTemplates) {
+        result.componentTemplates = selectedComponents;
+    }
+    if (providedTemplateIsValid) {
+        result.projectTemplate = findTemplateByNameOrLabel(projectTemplates, promptOptions.template);
+    }
+    if (projectTemplates && projectTemplates.length > 0) {
+        if (!result.projectTemplate) {
+            throw new Error(lib.prompts.selectProjectTemplatePrompt.errors.projectTemplateRequired);
+        }
+        return result;
+    }
+    return result;
+}

package/lib/prompts/selectPublicAppForMigrationPrompt.d.ts

@@ -0,0 +1,9 @@
+type PublicAppPromptResponse = {
+    appId: number;
+};
+export declare function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp, }: {
+    accountId: number | null;
+    accountName: string;
+    isMigratingApp?: boolean;
+}): Promise<PublicAppPromptResponse>;
+export {};

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -0,0 +1,68 @@
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLine } from '../ui/index.js';
+import { logError } from '../errorHandlers/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
+    try {
+        const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
+        const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
+        if (!filteredPublicApps.length ||
+            (isMigratingApp &&
+                !filteredPublicApps.some(app => !app.preventProjectMigrations || !app.listingInfo))) {
+            uiLine();
+            if (isMigratingApp) {
+                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigrationMessage(accountName)}`);
+            }
+            else {
+                uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
+            }
+            uiLine();
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
+        }
+        return filteredPublicApps;
+    }
+    catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
+        logError(error, accountId ? { accountId } : undefined);
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
+    }
+}
+export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {
+    const publicApps = await fetchPublicAppOptions(accountId, accountName, isMigratingApp);
+    return promptUser([
+        {
+            name: 'appId',
+            message: isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdMigrate(accountName)
+                : lib.prompts.selectPublicAppForMigrationPrompt.selectAppIdClone(accountName),
+            type: 'list',
+            choices: publicApps.map(app => {
+                const { preventProjectMigrations, listingInfo } = app;
+                if (isMigratingApp && preventProjectMigrations && listingInfo) {
+                    return {
+                        name: `${app.name} (${app.id})`,
+                        disabled: lib.prompts.selectPublicAppForMigrationPrompt.errors
+                            .cannotBeMigrated,
+                    };
+                }
+                return {
+                    name: `${app.name} (${app.id})`,
+                    value: app.id,
+                };
+            }),
+        },
+    ]);
+}

package/lib/prompts/setAsDefaultAccountPrompt.d.ts

@@ -0,0 +1 @@
+export declare function setAsDefaultAccountPrompt(accountName: string): Promise<boolean>;

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -0,0 +1,26 @@
+import { setConfigAccountAsDefault, getConfigDefaultAccountIfExists, getAllConfigAccounts, } from '@hubspot/local-dev-lib/config';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+import { uiLogger } from '../ui/logger.js';
+export async function setAsDefaultAccountPrompt(accountName) {
+    // Accounts for deprecated and new config
+    const defaultAccount = getConfigDefaultAccountIfExists();
+    const accounts = getAllConfigAccounts() || [];
+    const { setAsDefault } = await promptUser([
+        {
+            name: 'setAsDefault',
+            type: 'confirm',
+            when: accounts.length >= 1 && defaultAccount?.name !== accountName,
+            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
+        },
+    ]);
+    uiLogger.log('');
+    if (setAsDefault) {
+        setConfigAccountAsDefault(accountName);
+        uiLogger.success(lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount(accountName));
+    }
+    else if (defaultAccount) {
+        uiLogger.log(lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault(defaultAccount.name));
+    }
+    return setAsDefault;
+}