@hubspot/cli 7.7.34-experimental.0 → 7.8.0-beta.0

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);

package/lib/schema.js

@@ -1,13 +1,13 @@
 import chalk from 'chalk';
 import { table, getBorderCharacters } from 'table';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
+import { uiLogger } from './ui/logger.js';
 export function logSchemas(schemas) {
     const data = schemas
         .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
         .sort((a, b) => (a[1] > b[1] ? 1 : -1));
     if (data.length === 0) {
-        logger.log('No Schemas were found');
+        uiLogger.log('No Schemas were found');
         return;
     }
     data.unshift([
@@ -19,7 +19,7 @@ export function logSchemas(schemas) {
         singleLine: true,
         border: getBorderCharacters('honeywell'),
     };
-    logger.log(table(data, tableConfig));
+    uiLogger.log(table(data, tableConfig));
 }
 export async function listSchemas(accountId) {
     const { data } = await fetchObjectSchemas(accountId);

package/lib/serverlessLogs.js

@@ -1,6 +1,6 @@
 import https from 'https';
 import chalk from 'chalk';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
 import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
@@ -10,7 +10,7 @@ import { logError, ApiErrorContext } from './errorHandlers/index.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { handleExit, handleKeypress } from './process.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
-import { i18n } from './lang.js';
+import { lib } from '../lang/en.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
     if (typeof valueToEncode !== 'string') {
@@ -47,22 +47,20 @@ async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
         scopesData = resp.data;
     }
     catch (e) {
-        logger.debug(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError`, {
-            scopeGroup,
-        }));
-        logger.debug(e);
+        uiLogger.debug(lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError(scopeGroup));
+        uiLogger.debug(e);
         return;
     }
     const { portalScopesInGroup, userScopesInGroup } = scopesData;
     if (!portalScopesInGroup.length) {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope);
         return;
     }
     if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope);
     }
     else {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope);
     }
 }
 export async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
@@ -120,7 +118,7 @@ export async function tailLogs(accountId, name, fetchLatest, tailCall, compact =
 }
 export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {
-        logger.debug('Unable to display build output. No build log URL was provided.');
+        uiLogger.debug('Unable to display build output. No build log URL was provided.');
         return '';
     }
     return new Promise(resolve => {
@@ -135,16 +133,16 @@ export async function outputBuildLog(buildLogUrl) {
                     data += chunk;
                 });
                 response.on('end', () => {
-                    logger.log(data);
+                    uiLogger.log(data);
                     resolve(data);
                 });
             })
                 .on('error', () => {
-                logger.error('The build log could not be retrieved.');
+                uiLogger.error('The build log could not be retrieved.');
             });
         }
         catch (e) {
-            logger.error('The build log could not be retrieved.');
+            uiLogger.error('The build log could not be retrieved.');
             resolve('');
         }
     });

package/lib/theme/__tests__/migrate.test.d.ts

@@ -0,0 +1 @@
+export {};