@hubspot/cli 7.8.12-experimental.0 → 7.8.12-experimental.1

package/lib/prompts/promptUtils.js

@@ -1,11 +1,29 @@
 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('?') } };
 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') {
@@ -86,10 +104,7 @@ export async function promptUser(config) {
         }
     }
     catch (error) {
-        if (isUserCancellationError(error)) {
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        throw error;
+        handlePromptError(config, error);
     }
 }
 function handleRawListPrompt(config) {
@@ -139,8 +154,10 @@ function handleCheckboxPrompt(config) {
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleConfirmPrompt(config) {
-    return confirmPrompt(config.message, {
-        defaultAnswer: config.default,
+    return confirm({
+        message: config.message,
+        default: config.default,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleInputPrompt(config) {
@@ -165,12 +182,13 @@ function handleSelectPrompt(config) {
 }
 export async function confirmPrompt(message, options = {}) {
     const { defaultAnswer = true } = options;
-    const choice = await confirm({
+    const { confirm: result } = await promptUser({
+        name: 'confirm',
+        type: 'confirm',
         message,
         default: defaultAnswer,
-        theme: PROMPT_THEME,
     });
-    return choice;
+    return result;
 }
 export async function listPrompt(message, { choices, when, defaultAnswer, validate, loop, }) {
     const { choice } = await promptUser({

package/lib/prompts/sandboxesPrompt.js

@@ -1,5 +1,5 @@
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.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 { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
@@ -25,15 +25,15 @@ export async function sandboxTypePrompt() {
     return promptUser([
         {
             name: 'type',
-            message: i18n(`lib.prompts.sandboxesPrompt.type.message`),
+            message: lib.prompts.sandboxesPrompt.type.message,
             type: 'list',
             choices: [
                 {
-                    name: i18n(`lib.prompts.sandboxesPrompt.type.developer`),
+                    name: lib.prompts.sandboxesPrompt.type.developer,
                     value: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
                 {
-                    name: i18n(`lib.prompts.sandboxesPrompt.type.standard`),
+                    name: lib.prompts.sandboxesPrompt.type.standard,
                     value: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
                 },
             ],
@@ -52,9 +52,9 @@ export function deleteSandboxPrompt(promptParentAccount = false) {
     return promptUser([
         {
             name: 'account',
-            message: i18n(promptParentAccount
-                ? `lib.prompts.sandboxesPrompt.selectParentAccountName`
-                : `lib.prompts.sandboxesPrompt.selectAccountName`),
+            message: promptParentAccount
+                ? lib.prompts.sandboxesPrompt.selectParentAccountName
+                : lib.prompts.sandboxesPrompt.selectAccountName,
             type: 'list',
             pageSize: 20,
             choices,

package/lib/prompts/secretPrompt.js

@@ -1,12 +1,12 @@
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 export function secretValuePrompt() {
     return promptUser([
         {
             name: 'secretValue',
             type: 'password',
             mask: '*',
-            message: i18n(`lib.prompts.secretPrompt.enterValue`),
+            message: lib.prompts.secretPrompt.enterValue,
         },
     ]);
 }
@@ -15,7 +15,7 @@ export function secretNamePrompt() {
         {
             name: 'secretName',
             type: 'input',
-            message: i18n(`lib.prompts.secretPrompt.enterName`),
+            message: lib.prompts.secretPrompt.enterName,
         },
     ]);
 }

package/lib/prompts/selectAppPrompt.js

@@ -1,4 +1,4 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+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';
@@ -15,7 +15,7 @@ export async function selectAppPrompt(accountId, appId) {
         debugError(err);
     }
     if (availableApps.length === 0) {
-        logger.error(lib.prompts.selectAppPrompt.errors.noApps);
+        uiLogger.error(lib.prompts.selectAppPrompt.errors.noApps);
         return null;
     }
     if (appId) {
@@ -24,7 +24,7 @@ export async function selectAppPrompt(accountId, appId) {
             return targetApp;
         }
         else {
-            logger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
+            uiLogger.error(lib.prompts.selectAppPrompt.errors.invalidAppId);
         }
     }
     const appPromptValue = await listPrompt(lib.prompts.selectAppPrompt.selectAppId, {

package/lib/prompts/selectHubDBTablePrompt.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
@@ -10,18 +10,14 @@ async function fetchHubDBOptions(accountId) {
     try {
         const { data: { results: tables }, } = await fetchTables(accountId);
         if (tables.length === 0) {
-            logger.log(i18n(`lib.prompts.selectHubDBTablePrompt.errors.noTables`, {
-                accountId,
-            }));
+            uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
             process.exit(EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
         debugError(error, { accountId });
-        logger.error(i18n(`lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables`, {
-            accountId,
-        }));
+        uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
         process.exit(EXIT_CODES.ERROR);
     }
 }
@@ -32,7 +28,7 @@ export async function selectHubDBTablePrompt({ accountId, options, skipDestPromp
     return promptUser([
         {
             name: 'tableId',
-            message: i18n(`lib.prompts.selectHubDBTablePrompt.selectTable`),
+            message: lib.prompts.selectHubDBTablePrompt.selectTable,
             when: !id && !isValidTable,
             type: 'list',
             choices: hubdbTables.map(table => {
@@ -44,17 +40,17 @@ export async function selectHubDBTablePrompt({ accountId, options, skipDestPromp
         },
         {
             name: 'dest',
-            message: i18n(`lib.prompts.selectHubDBTablePrompt.enterDest`),
+            message: lib.prompts.selectHubDBTablePrompt.enterDest,
             when: !options.dest && !skipDestPrompt,
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.destRequired`);
+                    return lib.prompts.selectHubDBTablePrompt.errors.destRequired;
                 }
                 if (fs.existsSync(input)) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.invalidDest`);
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidDest;
                 }
                 if (!isValidPath(input)) {
-                    return i18n(`lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters`);
+                    return lib.prompts.selectHubDBTablePrompt.errors.invalidCharacters;
                 }
                 return true;
             },

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -1,14 +1,14 @@
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 import { uiLine } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
     try {
         if (!accountId) {
-            logger.error(i18n(`lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId`));
+            uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
             process.exit(EXIT_CODES.ERROR);
         }
         const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
@@ -16,15 +16,13 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
         if (!filteredPublicApps.length ||
             (isMigratingApp &&
                 !filteredPublicApps.some(app => !app.preventProjectMigrations || !app.listingInfo))) {
-            const headerTranslationKey = isMigratingApp
-                ? 'noAppsMigration'
-                : 'noAppsClone';
-            const messageTranslationKey = isMigratingApp
-                ? 'noAppsMigrationMessage'
-                : 'noAppsCloneMessage';
             uiLine();
-            logger.error(i18n(`lib.prompts.selectPublicAppForMigrationPrompt.errors.${headerTranslationKey}`));
-            logger.log(i18n(`lib.prompts.selectPublicAppForMigrationPrompt.errors.${messageTranslationKey}`, { accountName }));
+            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();
             process.exit(EXIT_CODES.SUCCESS);
         }
@@ -32,28 +30,26 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
     }
     catch (error) {
         logError(error, accountId ? { accountId } : undefined);
-        logger.error(i18n(`lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps`));
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
         process.exit(EXIT_CODES.ERROR);
     }
 }
 export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {
     const publicApps = await fetchPublicAppOptions(accountId, accountName, isMigratingApp);
-    const translationKey = isMigratingApp
-        ? 'selectAppIdMigrate'
-        : 'selectAppIdClone';
     return promptUser([
         {
             name: 'appId',
-            message: i18n(`lib.prompts.selectPublicAppForMigrationPrompt.${translationKey}`, {
-                accountName,
-            }),
+            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: i18n(`lib.prompts.selectPublicAppForMigrationPrompt.errors.cannotBeMigrated`),
+                        disabled: lib.prompts.selectPublicAppForMigrationPrompt.errors
+                            .cannotBeMigrated,
                     };
                 }
                 return {

package/lib/prompts/setAsDefaultAccountPrompt.js

@@ -1,6 +1,6 @@
 import { updateDefaultAccount, getConfigDefaultAccount, } from '@hubspot/local-dev-lib/config';
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 export async function setAsDefaultAccountPrompt(accountName) {
     // Accounts for deprecated and new config
@@ -10,20 +10,16 @@ export async function setAsDefaultAccountPrompt(accountName) {
             name: 'setAsDefault',
             type: 'confirm',
             when: defaultAccount !== accountName,
-            message: i18n(`lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage`),
+            message: lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccountMessage,
         },
     ]);
     uiLogger.log('');
     if (setAsDefault) {
         updateDefaultAccount(accountName);
-        uiLogger.success(i18n('lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount', {
-            accountName,
-        }));
+        uiLogger.success(lib.prompts.setAsDefaultAccountPrompt.setAsDefaultAccount(accountName));
     }
     else {
-        uiLogger.log(i18n('lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault', {
-            accountName: getConfigDefaultAccount(),
-        }));
+        uiLogger.log(lib.prompts.setAsDefaultAccountPrompt.keepingCurrentDefault(getConfigDefaultAccount()));
     }
     return setAsDefault;
 }

package/lib/prompts/uploadPrompt.js

@@ -1,29 +1,29 @@
 import path from 'path';
 import { getCwd } from '@hubspot/local-dev-lib/path';
 import { promptUser } from './promptUtils.js';
-import { i18n } from '../lang.js';
+import { lib } from '../../lang/en.js';
 export async function uploadPrompt(promptOptions = {}) {
     return promptUser([
         {
             name: 'src',
-            message: i18n(`lib.prompts.uploadPrompt.enterSrc`),
+            message: lib.prompts.uploadPrompt.enterSrc,
             when: !promptOptions.src,
             default: '.',
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.uploadPrompt.errors.srcRequired`);
+                    return lib.prompts.uploadPrompt.errors.srcRequired;
                 }
                 return true;
             },
         },
         {
             name: 'dest',
-            message: i18n(`lib.prompts.uploadPrompt.enterDest`),
+            message: lib.prompts.uploadPrompt.enterDest,
             when: !promptOptions.dest,
             default: path.basename(getCwd()),
             validate: (input) => {
                 if (!input) {
-                    return i18n(`lib.prompts.uploadPrompt.errors.destRequired`);
+                    return lib.prompts.uploadPrompt.errors.destRequired;
                 }
                 return true;
             },

package/lib/sandboxSync.js

@@ -1,14 +1,14 @@
 import SpinniesManager from './ui/SpinniesManager.js';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
 import { getAccountId } from '@hubspot/local-dev-lib/config';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
-import { i18n } from './lang.js';
+import { lib } from '../lang/en.js';
 import { getAvailableSyncTypes, getSandboxTypeAsString } from './sandboxes.js';
 import { debugError, logError, ApiErrorContext, } from './errorHandlers/index.js';
-import { uiAccountDescription, uiLine, uiLink, uiCommandDisabledBanner, } from './ui/index.js';
+import { uiAccountDescription, uiLine, uiCommandDisabledBanner, } from './ui/index.js';
 import { isDevelopmentSandbox } from './accountTypes.js';
 export async function syncSandbox(accountConfig, parentAccountConfig, env, syncTasks, slimInfoMessage = false) {
     const id = getAccountIdentifier(accountConfig);
@@ -17,14 +17,9 @@ export async function syncSandbox(accountConfig, parentAccountConfig, env, syncT
     const parentAccountId = getAccountId(parentId);
     const isDevSandbox = isDevelopmentSandbox(accountConfig);
     if (!accountId || !parentAccountId) {
-        throw new Error(i18n(`lib.sandbox.sync.failure.invalidUser`, {
-            accountName: accountId
-                ? uiAccountDescription(accountId)
-                : id.toString(),
-            parentAccountName: parentAccountId
-                ? uiAccountDescription(parentAccountId)
-                : parentId.toString(),
-        }));
+        throw new Error(lib.sandbox.sync.failure.invalidUser(accountId ? uiAccountDescription(accountId) : id.toString(), parentAccountId
+            ? uiAccountDescription(parentAccountId)
+            : parentId.toString()));
     }
     SpinniesManager.init({
         succeedColor: 'white',
@@ -40,45 +35,37 @@ export async function syncSandbox(accountConfig, parentAccountConfig, env, syncT
             availableSyncTasks = await getAvailableSyncTypes(parentAccountConfig, accountConfig);
         }
         SpinniesManager.add('sandboxSync', {
-            text: i18n(`lib.sandbox.sync.loading.startSync`),
+            text: lib.sandbox.sync.loading.startSync,
         });
         await initiateSync(parentAccountId, accountId, availableSyncTasks, accountId);
         const spinniesText = isDevSandbox
-            ? `lib.sandbox.sync.loading.succeedDevSb`
-            : `lib.sandbox.sync.loading.succeed`;
+            ? lib.sandbox.sync.loading.succeedDevSb(accountId)
+            : lib.sandbox.sync.loading.succeed(accountId);
         SpinniesManager.succeed('sandboxSync', {
-            text: i18n(slimInfoMessage
-                ? `lib.sandbox.sync.loading.successDevSbInfo`
-                : spinniesText, {
-                accountName: uiAccountDescription(accountId),
-                url: uiLink(i18n(`lib.sandbox.sync.info.syncStatusDetailsLinkText`), syncStatusUrl),
-            }),
+            text: slimInfoMessage
+                ? lib.sandbox.sync.loading.successDevSbInfo(accountId, syncStatusUrl)
+                : spinniesText,
         });
     }
     catch (err) {
         debugError(err);
         SpinniesManager.fail('sandboxSync', {
-            text: i18n(`lib.sandbox.sync.loading.fail`),
+            text: lib.sandbox.sync.loading.fail(accountId),
         });
-        logger.log('');
+        uiLogger.log('');
         if (isSpecifiedError(err, {
             statusCode: 403,
             category: 'BANNED',
             subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
         })) {
-            logger.error(i18n(`lib.sandbox.sync.failure.invalidUser`, {
-                accountName: uiAccountDescription(accountId),
-                parentAccountName: uiAccountDescription(parentAccountId),
-            }));
+            uiLogger.error(lib.sandbox.sync.failure.invalidUser(uiAccountDescription(accountId), uiAccountDescription(parentAccountId)));
         }
         else if (isSpecifiedError(err, {
             statusCode: 429,
             category: 'RATE_LIMITS',
             subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
         })) {
-            logger.error(i18n(`lib.sandbox.sync.failure.syncInProgress`, {
-                url: `${baseUrl}/sandboxes-developer/${parentAccountId}/syncactivitylog`,
-            }));
+            uiLogger.error(lib.sandbox.sync.failure.syncInProgress(`${baseUrl}/sandboxes-developer/${parentAccountId}/syncactivitylog`));
         }
         else if (isSpecifiedError(err, {
             statusCode: 403,
@@ -86,18 +73,14 @@ export async function syncSandbox(accountConfig, parentAccountConfig, env, syncT
             subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
         })) {
             // This will only trigger if a user is not a super admin of the target account.
-            logger.error(i18n(`lib.sandbox.sync.failure.notSuperAdmin`, {
-                account: uiAccountDescription(accountId),
-            }));
+            uiLogger.error(lib.sandbox.sync.failure.notSuperAdmin(accountId));
         }
         else if (isSpecifiedError(err, {
             statusCode: 404,
             category: 'OBJECT_NOT_FOUND',
             subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
         })) {
-            logger.error(i18n(`lib.sandbox.sync.failure.objectNotFound`, {
-                account: uiAccountDescription(accountId),
-            }));
+            uiLogger.error(lib.sandbox.sync.failure.objectNotFound(accountId));
         }
         else if (isSpecifiedError(err, {
             statusCode: 404,
@@ -110,16 +93,16 @@ export async function syncSandbox(accountConfig, parentAccountConfig, env, syncT
                 request: 'sandbox sync',
             }));
         }
-        logger.log('');
+        uiLogger.log('');
         throw err;
     }
     if (!slimInfoMessage) {
-        logger.log();
+        uiLogger.log('');
         uiLine();
-        logger.info(i18n(`lib.sandbox.sync.info.${isDevSandbox ? 'syncMessageDevSb' : 'syncMessage'}`, {
-            url: uiLink(i18n(`lib.sandbox.sync.info.syncStatusDetailsLinkText`), syncStatusUrl),
-        }));
+        uiLogger.info(isDevSandbox
+            ? lib.sandbox.sync.info.syncMessageDevSb(syncStatusUrl)
+            : lib.sandbox.sync.info.syncMessage(syncStatusUrl));
         uiLine();
-        logger.log();
+        uiLogger.log('');
     }
 }

package/lib/sandboxes.js

@@ -1,4 +1,3 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
@@ -6,9 +5,10 @@ import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
-import { i18n } from './lang.js';
-import { uiAccountDescription } from './ui/index.js';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
 import { logError } from './errorHandlers/index.js';
+import { uiAccountDescription } from './ui/index.js';
 export const SYNC_TYPES = {
     OBJECT_RECORDS: 'object-records',
 };
@@ -54,11 +54,11 @@ export async function getAvailableSyncTypes(parentAccountConfig, config) {
     const id = getAccountIdentifier(config);
     const portalId = getAccountId(id);
     if (!parentPortalId || !portalId) {
-        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
     }
     const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
     if (!syncTypes) {
-        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
     }
     return syncTypes.map(t => ({ type: t.name }));
 }
@@ -66,91 +66,63 @@ export async function validateSandboxUsageLimits(accountConfig, sandboxType, env
     const id = getAccountIdentifier(accountConfig);
     const accountId = getAccountId(id);
     if (!accountId) {
-        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
     }
     const { data: { usage }, } = await getSandboxUsageLimits(accountId);
     if (!usage) {
-        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
     }
     if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
         if (usage['DEVELOPER'].available === 0) {
             const devSandboxLimit = usage['DEVELOPER'].limit;
-            const plural = devSandboxLimit !== 1;
             const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
             if (hasDevelopmentSandboxes) {
-                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.developer.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: devSandboxLimit,
-                }));
+                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
             }
             else {
                 const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(i18n(`lib.sandbox.create.failure.limit.developer.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: devSandboxLimit,
-                    link: `${baseUrl}/sandboxes-developer/${accountId}/development`,
-                }));
+                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
             }
         }
     }
     if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
         if (usage['STANDARD'].available === 0) {
             const standardSandboxLimit = usage['STANDARD'].limit;
-            const plural = standardSandboxLimit !== 1;
             const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
             if (hasStandardSandboxes) {
-                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.standard.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: standardSandboxLimit,
-                }));
+                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
             }
             else {
                 const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(i18n(`lib.sandbox.create.failure.limit.standard.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: standardSandboxLimit,
-                    link: `${baseUrl}/sandboxes-developer/${accountId}/standard`,
-                }));
+                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
             }
         }
     }
 }
 export function handleSandboxCreateError(err, env, name, accountId) {
     if (isMissingScopeError(err)) {
-        logger.error(i18n(`lib.sandbox.create.failure.scopes.message`, {
-            accountName: uiAccountDescription(accountId),
-        }));
+        uiLogger.error(lib.sandbox.create.failure.scopes.message);
         const websiteOrigin = getHubSpotWebsiteOrigin(env);
         const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        logger.info(i18n(`lib.sandbox.create.failure.scopes.instructions`, {
-            accountName: uiAccountDescription(accountId),
-            url,
-        }));
+        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
     }
     else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
     })) {
-        logger.log('');
-        logger.error(i18n(`lib.sandbox.create.failure.invalidUser`, {
-            accountName: name,
-            parentAccountName: uiAccountDescription(accountId),
-        }));
-        logger.log('');
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
+        uiLogger.log('');
     }
     else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
     })) {
-        logger.log('');
-        logger.error(i18n(`lib.sandbox.create.failure.403Gating`, {
-            accountName: name,
-            parentAccountName: uiAccountDescription(accountId),
-            accountId,
-        }));
-        logger.log('');
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
+        uiLogger.log('');
     }
     else {
         logError(err);