@hubspot/cli 7.7.20-experimental.0 → 7.7.21-experimental.0

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,36 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectSandboxTargetAccountPrompt = selectSandboxTargetAccountPrompt;
-exports.selectDeveloperTestTargetAccountPrompt = selectDeveloperTestTargetAccountPrompt;
-exports.confirmDefaultAccountPrompt = confirmDefaultAccountPrompt;
-exports.confirmUseExistingDeveloperTestAccountPrompt = confirmUseExistingDeveloperTestAccountPrompt;
-const config_1 = require("@hubspot/local-dev-lib/config");
-const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
-const accountTypes_1 = require("../accountTypes");
-const exitCodes_1 = require("../enums/exitCodes");
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+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 { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { uiAccountDescription, uiCommandReference } from '../ui/index.js';
+import { isSandbox } from '../accountTypes.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
     return {
-        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(accountConfig), false),
+        name: uiAccountDescription(getAccountIdentifier(accountConfig), false),
         value: {
-            targetAccountId: (0, config_1.getAccountId)(accountConfig.name),
+            targetAccountId: getAccountId(accountConfig.name),
             createNestedAccount: false,
             parentAccountId,
         },
     };
 }
 function getNonConfigDeveloperTestAccountName(account) {
-    return `${account.accountName} [${config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
+    return `${account.accountName} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
 }
-async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
+export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = getAccountId(defaultAccountConfig.name);
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
@@ -38,30 +32,30 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     };
     try {
         if (defaultAccountId) {
-            const { data } = await (0, sandboxHubs_1.getSandboxUsageLimits)(defaultAccountId);
+            const { data } = await getSandboxUsageLimits(defaultAccountId);
             sandboxUsage = data.usage;
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     catch (err) {
-        logger_1.logger.debug('Unable to fetch sandbox usage limits: ', err);
+        logger.debug('Unable to fetch sandbox usage limits: ', err);
     }
     const sandboxAccounts = accounts
         .reverse()
-        .filter(config => (0, accountTypes_1.isSandbox)(config) && config.parentAccountId === defaultAccountId);
+        .filter(config => isSandbox(config) && config.parentAccountId === defaultAccountId);
     let disabledMessage = false;
     if (sandboxUsage['DEVELOPER'] && sandboxUsage['DEVELOPER'].available === 0) {
         if (sandboxAccounts.length < sandboxUsage['DEVELOPER'].limit) {
-            disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion`, {
-                authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+            disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion`, {
+                authCommand: uiCommandReference('hs auth'),
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
         else {
-            disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimit`, {
+            disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.sandboxLimit`, {
                 limit: sandboxUsage['DEVELOPER'].limit,
             });
         }
@@ -69,13 +63,13 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     // Order choices by Developer Sandbox -> Standard Sandbox
     choices = [
         ...sandboxAccounts
-            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
             .map(mapNestedAccount),
         ...sandboxAccounts
-            .filter(a => a.accountType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
+            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
             .map(mapNestedAccount),
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -83,7 +77,7 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
             disabled: disabledMessage,
         },
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.chooseDefaultAccountOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.chooseDefaultAccountOption`),
             value: {
                 targetAccountId: defaultAccountId,
                 createNestedAccount: false,
@@ -92,34 +86,34 @@ async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig)
     ];
     return selectTargetAccountPrompt(defaultAccountId, 'sandbox account', choices);
 }
-async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = (0, config_1.getAccountId)(defaultAccountConfig.name);
+export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
+    const defaultAccountId = getAccountId(defaultAccountConfig.name);
     let devTestAccountsResponse;
     try {
         if (defaultAccountId) {
-            const { data } = await (0, developerTestAccounts_1.fetchDeveloperTestAccounts)(defaultAccountId);
+            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
             devTestAccountsResponse = data;
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`lib.prompts.projectDevTargetAccountPrompt.noAccountId`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     catch (err) {
-        logger_1.logger.debug('Unable to fetch developer test account usage limits: ', err);
+        logger.debug('Unable to fetch developer test account usage limits: ', err);
     }
     let disabledMessage = false;
     if (devTestAccountsResponse &&
         devTestAccountsResponse.results.length >=
             devTestAccountsResponse.maxTestPortals) {
-        disabledMessage = (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit`, {
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
+        disabledMessage = i18n(`lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit`, {
+            authCommand: uiCommandReference('hs auth'),
             limit: devTestAccountsResponse.maxTestPortals,
         });
     }
     const devTestAccounts = [];
     if (devTestAccountsResponse && devTestAccountsResponse.results) {
-        const accountIds = accounts.map(account => (0, getAccountIdentifier_1.getAccountIdentifier)(account));
+        const accountIds = accounts.map(account => getAccountIdentifier(account));
         devTestAccountsResponse.results.forEach(acct => {
             const inConfig = accountIds.includes(acct.id);
             devTestAccounts.push({
@@ -136,7 +130,7 @@ async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountCo
     const choices = [
         ...devTestAccounts,
         {
-            name: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.createNewDeveloperTestAccountOption`),
+            name: i18n(`lib.prompts.projectDevTargetAccountPrompt.createNewDeveloperTestAccountOption`),
             value: {
                 targetAccountId: null,
                 createNestedAccount: true,
@@ -144,16 +138,16 @@ async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountCo
             disabled: disabledMessage,
         },
     ];
-    return selectTargetAccountPrompt(defaultAccountId, config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
+    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 (0, promptUtils_1.promptUser)([
+    const { targetAccountInfo } = await promptUser([
         {
             name: 'targetAccountInfo',
             type: 'list',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.promptMessage`, {
-                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.promptMessage`, {
+                accountIdentifier: uiAccountDescription(accountId),
                 accountType,
             }),
             choices,
@@ -161,12 +155,12 @@ async function selectTargetAccountPrompt(defaultAccountId, accountType, choices)
     ]);
     return targetAccountInfo;
 }
-async function confirmDefaultAccountPrompt(accountName, accountType) {
-    const { useDefaultAccount } = await (0, promptUtils_1.promptUser)([
+export async function confirmDefaultAccountPrompt(accountName, accountType) {
+    const { useDefaultAccount } = await promptUser([
         {
             name: 'useDefaultAccount',
             type: 'confirm',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount`, {
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount`, {
                 accountName,
                 accountType,
             }),
@@ -174,12 +168,12 @@ async function confirmDefaultAccountPrompt(accountName, accountType) {
     ]);
     return useDefaultAccount;
 }
-async function confirmUseExistingDeveloperTestAccountPrompt(account) {
-    const { confirmUseExistingDeveloperTestAccount } = await (0, promptUtils_1.promptUser)([
+export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
+    const { confirmUseExistingDeveloperTestAccount } = await promptUser([
         {
             name: 'confirmUseExistingDeveloperTestAccount',
             type: 'confirm',
-            message: (0, lang_1.i18n)(`lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount`, {
+            message: i18n(`lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount`, {
                 accountName: getNonConfigDeveloperTestAccountName(account),
             }),
         },

package/lib/prompts/projectNameAndDestPrompt.d.ts

@@ -1,3 +1,3 @@
-import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt';
+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

@@ -1,40 +1,33 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectNameAndDestPrompt = projectNameAndDestPrompt;
-exports.validateProjectDirectory = validateProjectDirectory;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const en_1 = require("../../lang/en");
-const promptUtils_1 = require("./promptUtils");
-const constants_1 = require("../constants");
-async function projectNameAndDestPrompt(promptOptions) {
-    const result = await (0, promptUtils_1.promptUser)([
+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: en_1.lib.prompts.projectNameAndDestPrompt.enterName,
+            message: lib.prompts.projectNameAndDestPrompt.enterName,
             when: !promptOptions.name,
             validate: (input) => {
                 if (!input) {
-                    return en_1.lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
+                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: en_1.lib.prompts.projectNameAndDestPrompt.enterDest,
+            message: lib.prompts.projectNameAndDestPrompt.enterDest,
             when: !promptOptions.dest,
-            default: answers => {
-                const projectName = (0, path_2.sanitizeFileName)(promptOptions.name || answers.name);
-                return path_1.default.resolve((0, path_2.getCwd)(), projectName);
+            default: (answers) => {
+                const projectName = sanitizeFileName(promptOptions.name || answers.name);
+                return path.resolve(getCwd(), projectName);
             },
             validate: validateProjectDirectory,
-            filter: input => {
-                return (0, path_2.untildify)(input);
+            filter: (input) => {
+                return untildify(input);
             },
         },
     ]);
@@ -46,15 +39,15 @@ async function projectNameAndDestPrompt(promptOptions) {
     }
     return result;
 }
-function validateProjectDirectory(input) {
+export function validateProjectDirectory(input) {
     if (!input) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.destRequired;
+        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
     }
-    if (fs_1.default.existsSync(path_1.default.resolve((0, path_2.getCwd)(), path_1.default.join(input, constants_1.PROJECT_CONFIG_FILE)))) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
+    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
     }
-    if (!(0, path_2.isValidPath)(input)) {
-        return en_1.lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
+    if (!isValidPath(input)) {
+        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
     }
     return true;
 }

package/lib/prompts/projectNamePrompt.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectNamePrompt = projectNamePrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ensureProjectExists_1 = require("../projects/ensureProjectExists");
-const ui_1 = require("../ui");
-async function projectNamePrompt(accountId, options = {}) {
-    const result = await (0, promptUtils_1.promptUser)({
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import { uiAccountDescription } from '../ui/index.js';
+export async function projectNamePrompt(accountId, options = {}) {
+    const result = await promptUser({
         name: 'projectName',
-        message: (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.enterName`),
+        message: i18n(`lib.prompts.projectNamePrompt.enterName`),
         when: !options.project,
         validate: async (val) => {
             if (typeof val !== 'string' || !val) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.invalidName`);
+                return i18n(`lib.prompts.projectNamePrompt.errors.invalidName`);
             }
-            const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(accountId, val, {
+            const { projectExists } = await ensureProjectExists(accountId, val, {
                 allowCreate: false,
                 noLogs: true,
             });
             if (!projectExists) {
-                return (0, lang_1.i18n)(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
+                return i18n(`lib.prompts.projectNamePrompt.errors.projectDoesNotExist`, {
                     projectName: val,
-                    accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+                    accountIdentifier: uiAccountDescription(accountId),
                 });
             }
             return true;

package/lib/prompts/projectsLogsPrompt.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectLogsPrompt = projectLogsPrompt;
-const lang_1 = require("../lang");
-const promptUtils_1 = require("./promptUtils");
-async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
+import { i18n } from '../lang.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 (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'functionName',
             type: 'list',
-            message: (0, lang_1.i18n)(`lib.prompts.projectLogsPrompt.functionName`, {
+            message: i18n(`lib.prompts.projectLogsPrompt.functionName`, {
                 projectName,
             }),
             when: () => (!promptOptions || !promptOptions.function) &&

package/lib/prompts/promptUtils.d.ts

@@ -1,5 +1,5 @@
 import { Separator as _Separator } from '@inquirer/prompts';
-import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts';
+import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
 export declare const Separator: _Separator;
 export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
 export declare function confirmPrompt(message: string, options?: {

package/lib/prompts/promptUtils.js

@@ -1,18 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Separator = void 0;
-exports.promptUser = promptUser;
-exports.confirmPrompt = confirmPrompt;
-exports.listPrompt = listPrompt;
-exports.inputPrompt = inputPrompt;
-const prompts_1 = require("@inquirer/prompts");
-exports.Separator = new prompts_1.Separator();
+import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
+export const Separator = new _Separator();
 function mapPromptChoicesToChoices(choices) {
     return (choices?.map(choice => {
         if (typeof choice === 'string') {
             return { value: choice, name: choice };
         }
-        else if (choice instanceof prompts_1.Separator) {
+        else if (choice instanceof _Separator) {
             return choice;
         }
         return {
@@ -54,7 +47,7 @@ function handleArrayConfig(config) {
         return result;
     })();
 }
-function promptUser(config) {
+export function promptUser(config) {
     if (Array.isArray(config)) {
         return handleArrayConfig(config);
     }
@@ -90,11 +83,11 @@ function promptUser(config) {
 function handleRawListPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
     choices.map((choice, index) => {
-        if (!(choice instanceof prompts_1.Separator)) {
+        if (!(choice instanceof _Separator)) {
             choice.name = `${index + 1}) ${choice.name}`;
         }
     });
-    return (0, prompts_1.select)({
+    return select({
         message: config.message,
         choices: choices,
         pageSize: config.pageSize,
@@ -102,14 +95,14 @@ function handleRawListPrompt(config) {
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleNumberPrompt(config) {
-    return (0, prompts_1.number)({
+    return number({
         message: config.message,
         default: config.default,
         validate: config.validate,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handlePasswordPrompt(config) {
-    return (0, prompts_1.password)({
+    return password({
         message: config.message,
         mask: '*',
         validate: config.validate,
@@ -117,7 +110,7 @@ function handlePasswordPrompt(config) {
 }
 function handleCheckboxPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
-    return (0, prompts_1.checkbox)({
+    return checkbox({
         message: config.message,
         choices: choices,
         pageSize: config.pageSize,
@@ -130,7 +123,7 @@ function handleConfirmPrompt(config) {
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleInputPrompt(config) {
-    return (0, prompts_1.input)({
+    return input({
         message: config.message,
         default: config.default,
         validate: config.validate,
@@ -139,22 +132,22 @@ function handleInputPrompt(config) {
 }
 function handleSelectPrompt(config) {
     const choices = mapPromptChoicesToChoices(config.choices);
-    return (0, prompts_1.select)({
+    return select({
         message: config.message,
         choices: choices,
         default: config.default,
         pageSize: config.pageSize,
     }).then(resp => ({ [config.name]: resp }));
 }
-async function confirmPrompt(message, options = {}) {
+export async function confirmPrompt(message, options = {}) {
     const { defaultAnswer = true } = options;
-    const choice = await (0, prompts_1.confirm)({
+    const choice = await confirm({
         message,
         default: defaultAnswer,
     });
     return choice;
 }
-async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
+export async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
     const { choice } = await promptUser({
         name: 'choice',
         type: 'list',
@@ -166,7 +159,7 @@ async function listPrompt(message, { choices, when, defaultAnswer, validate, })
     });
     return choice;
 }
-async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
+export async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
     const { input } = await promptUser({
         name: 'input',
         type: 'input',

package/lib/prompts/sandboxesPrompt.d.ts

@@ -1,4 +1,4 @@
-import { SandboxAccountType } from '../../types/Sandboxes';
+import { SandboxAccountType } from '../../types/sandboxes.js';
 type SandboxTypePromptResponse = {
     type: SandboxAccountType;
 };

package/lib/prompts/sandboxesPrompt.js

@@ -1,68 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sandboxTypePrompt = sandboxTypePrompt;
-exports.deleteSandboxPrompt = deleteSandboxPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-const ui_1 = require("../ui");
-const config_1 = require("@hubspot/local-dev-lib/constants/config");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
-const accountTypes_1 = require("../accountTypes");
-const config_2 = require("@hubspot/local-dev-lib/config");
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
+import { isSandbox } from '../accountTypes.js';
+import { getConfigDefaultAccount, getConfigAccounts, } from '@hubspot/local-dev-lib/config';
 function mapSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => (0, accountTypes_1.isSandbox)(p))
+        ?.filter(p => isSandbox(p))
         .map(p => ({
-        name: (0, ui_1.uiAccountDescription)((0, getAccountIdentifier_1.getAccountIdentifier)(p), false),
-        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
+        name: uiAccountDescription(getAccountIdentifier(p), false),
+        value: p.name || getAccountIdentifier(p),
     })) || []);
 }
 function mapNonSandboxAccountChoices(portals) {
     return (portals
-        ?.filter(p => !(0, accountTypes_1.isSandbox)(p))
+        ?.filter(p => !isSandbox(p))
         .map(p => ({
-        name: `${p.name} (${(0, getAccountIdentifier_1.getAccountIdentifier)(p)})`,
-        value: p.name || (0, getAccountIdentifier_1.getAccountIdentifier)(p),
+        name: `${p.name} (${getAccountIdentifier(p)})`,
+        value: p.name || getAccountIdentifier(p),
     })) || []);
 }
-async function sandboxTypePrompt() {
-    return (0, promptUtils_1.promptUser)([
+export async function sandboxTypePrompt() {
+    return promptUser([
         {
             name: 'type',
-            message: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.message`),
+            message: i18n(`lib.prompts.sandboxesPrompt.type.message`),
             type: 'list',
             choices: [
                 {
-                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.developer`),
-                    value: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                    name: i18n(`lib.prompts.sandboxesPrompt.type.developer`),
+                    value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
                 {
-                    name: (0, lang_1.i18n)(`lib.prompts.sandboxesPrompt.type.standard`),
-                    value: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+                    name: i18n(`lib.prompts.sandboxesPrompt.type.standard`),
+                    value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
                 },
             ],
-            default: config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+            default: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         },
     ]);
 }
-function deleteSandboxPrompt(promptParentAccount = false) {
-    const accountsList = (0, config_2.getConfigAccounts)();
+export function deleteSandboxPrompt(promptParentAccount = false) {
+    const accountsList = getConfigAccounts();
     const choices = promptParentAccount
         ? mapNonSandboxAccountChoices(accountsList)
         : mapSandboxAccountChoices(accountsList);
     if (!choices.length) {
         return Promise.resolve(undefined);
     }
-    return (0, promptUtils_1.promptUser)([
+    return promptUser([
         {
             name: 'account',
-            message: (0, lang_1.i18n)(promptParentAccount
+            message: i18n(promptParentAccount
                 ? `lib.prompts.sandboxesPrompt.selectParentAccountName`
                 : `lib.prompts.sandboxesPrompt.selectAccountName`),
             type: 'list',
             pageSize: 20,
             choices,
-            default: (0, config_2.getConfigDefaultAccount)(),
+            default: getConfigDefaultAccount(),
         },
     ]);
 }

package/lib/prompts/secretPrompt.js

@@ -1,31 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.secretValuePrompt = secretValuePrompt;
-exports.secretNamePrompt = secretNamePrompt;
-exports.secretListPrompt = secretListPrompt;
-const promptUtils_1 = require("./promptUtils");
-const lang_1 = require("../lang");
-function secretValuePrompt() {
-    return (0, promptUtils_1.promptUser)([
+import { promptUser } from './promptUtils.js';
+import { i18n } from '../lang.js';
+export function secretValuePrompt() {
+    return promptUser([
         {
             name: 'secretValue',
             type: 'password',
             mask: '*',
-            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterValue`),
+            message: i18n(`lib.prompts.secretPrompt.enterValue`),
         },
     ]);
 }
-function secretNamePrompt() {
-    return (0, promptUtils_1.promptUser)([
+export function secretNamePrompt() {
+    return promptUser([
         {
             name: 'secretName',
             type: 'input',
-            message: (0, lang_1.i18n)(`lib.prompts.secretPrompt.enterName`),
+            message: i18n(`lib.prompts.secretPrompt.enterName`),
         },
     ]);
 }
-function secretListPrompt(secrets, message) {
-    return (0, promptUtils_1.promptUser)([
+export function secretListPrompt(secrets, message) {
+    return promptUser([
         {
             name: 'secretToModify',
             type: 'list',