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

package/lib/middleware/__test__/commandTargetingUtils.test.js

@@ -0,0 +1,99 @@
+import * as cliConfig from '@hubspot/local-dev-lib/config';
+import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from '../commandTargetingUtils.js';
+vi.mock('@hubspot/local-dev-lib/config');
+const configFileExistsSpy = vi.spyOn(cliConfig, 'configFileExists');
+const targetCommandMap = {
+    init: true,
+    account: {
+        use: true,
+    },
+    project: {
+        deploy: true,
+    },
+};
+describe('lib/middleware/commandTargetingUtils', () => {
+    describe('isTargetedCommand()', () => {
+        it('should return true for a direct target command', () => {
+            const result = isTargetedCommand(['init'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command with a subcommand', () => {
+            const result = isTargetedCommand(['account'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return true for a nested target command', () => {
+            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a non-existent command', () => {
+            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-targeted command', () => {
+            const result = isTargetedCommand(['auth'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a command with a targeted subcommand', () => {
+            const result = isTargetedCommand(['project'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-existent subcommand', () => {
+            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for an empty command array', () => {
+            const result = isTargetedCommand([], targetCommandMap);
+            expect(result).toBe(false);
+        });
+    });
+    describe('shouldLoadConfigForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require a config file', () => {
+            const result = shouldLoadConfigForCommand(['init']);
+            expect(result).toBe(false);
+        });
+        it('should return false when the user is trying to migrate the global config', () => {
+            configFileExistsSpy.mockReturnValue(false);
+            const result = shouldLoadConfigForCommand(['config', 'migrate']);
+            expect(result).toBe(false);
+        });
+        it('should return true when the global config file does exist', () => {
+            configFileExistsSpy.mockReturnValue(true);
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+    });
+    describe('shouldRunAccountValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunAccountValidationForCommand([
+                'project',
+                'upload',
+            ]);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require account validation', () => {
+            const result1 = shouldRunAccountValidationForCommand(['init']);
+            const result2 = shouldRunAccountValidationForCommand(['auth']);
+            const result3 = shouldRunAccountValidationForCommand([
+                'accounts',
+                'list',
+            ]);
+            expect(result1).toBe(false);
+            expect(result2).toBe(false);
+            expect(result3).toBe(false);
+        });
+    });
+    describe('shouldRunConfigValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunConfigValidationForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require config validation', () => {
+            const result = shouldRunConfigValidationForCommand(['init']);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/middleware/__test__/configMiddleware.test.js

@@ -1,10 +1,10 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 import * as cliConfig from '@hubspot/local-dev-lib/config';
 import * as validation from '../../validation.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
-import { handleDeprecatedEnvVariables, injectAccountIdMiddleware, loadConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
-vi.mock('@hubspot/local-dev-lib/logger', () => ({
-    logger: {
+import { handleDeprecatedEnvVariables, injectAccountIdMiddleware, loadAndValidateConfigMiddleware, validateAccountOptions, } from '../configMiddleware.js';
+vi.mock('../../ui/logger.js', () => ({
+    uiLogger: {
         error: vi.fn(),
         log: vi.fn(),
     },
@@ -39,7 +39,7 @@ describe('lib/middleware/configMiddleware', () => {
                 $0: 'hs',
             };
             handleDeprecatedEnvVariables(argv);
-            expect(logger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
+            expect(uiLogger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
             expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('123');
             process.env = originalEnv;
         });
@@ -56,7 +56,7 @@ describe('lib/middleware/configMiddleware', () => {
                 $0: 'hs',
             };
             handleDeprecatedEnvVariables(argv);
-            expect(logger.log).not.toHaveBeenCalled();
+            expect(uiLogger.log).not.toHaveBeenCalled();
             expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('456');
             process.env = originalEnv;
         });
@@ -93,7 +93,7 @@ describe('lib/middleware/configMiddleware', () => {
             expect(getAccountIdSpy).toHaveBeenCalledWith('test-account');
         });
     });
-    describe('loadConfigMiddleware()', () => {
+    describe('loadAndValidateConfigMiddleware()', () => {
         it('should exit with error when config file exists and --config flag is used', async () => {
             configFileExistsSpy.mockReturnValue(true);
             const argv = {
@@ -101,9 +101,9 @@ describe('lib/middleware/configMiddleware', () => {
                 config: 'custom-config.json',
                 $0: 'hs',
             };
-            await expect(loadConfigMiddleware(argv)).rejects.toThrow();
+            await expect(loadAndValidateConfigMiddleware(argv)).rejects.toThrow();
             expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
+            expect(uiLogger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
         });
         it('should load config and validate for non-init commands', async () => {
             configFileExistsSpy.mockReturnValue(false);
@@ -113,7 +113,7 @@ describe('lib/middleware/configMiddleware', () => {
                 _: ['some-command'],
                 $0: 'hs',
             };
-            await loadConfigMiddleware(argv);
+            await loadAndValidateConfigMiddleware(argv);
             expect(loadConfigSpy).toHaveBeenCalled();
             expect(validateConfigSpy).toHaveBeenCalled();
         });
@@ -123,7 +123,7 @@ describe('lib/middleware/configMiddleware', () => {
                 _: ['init'],
                 $0: 'hs',
             };
-            await loadConfigMiddleware(argv);
+            await loadAndValidateConfigMiddleware(argv);
             expect(loadConfigSpy).not.toHaveBeenCalled();
             expect(validateConfigSpy).not.toHaveBeenCalled();
         });

package/lib/middleware/__test__/yargsChecksMiddleware.test.js

@@ -1,16 +1,14 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import * as projectsConfig from '../../projects/config.js';
 import { performChecks } from '../yargsChecksMiddleware.js';
-vi.mock('@hubspot/local-dev-lib/logger', () => ({
-    logger: {
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+vi.mock('../../ui/logger', () => ({
+    uiLogger: {
         error: vi.fn(),
     },
 }));
 vi.mock('../../projects/config');
-vi.mock('../../lang', () => ({
-    i18n: vi.fn(key => key),
-}));
 const getIsInProjectSpy = vi.spyOn(projectsConfig, 'getIsInProject');
 const processExitSpy = vi.spyOn(process, 'exit');
 describe('lib/middleware/yargsChecksMiddleware', () => {
@@ -29,7 +27,7 @@ describe('lib/middleware/yargsChecksMiddleware', () => {
             getIsInProjectSpy.mockReturnValue(true);
             expect(() => performChecks(argv)).toThrow();
             expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith('commands.generalErrors.srcIsProject');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.generalErrors.srcIsProject(argv.src, argv._.toString()));
         });
         it('should return true when no checks fail', () => {
             const argv = {
@@ -40,7 +38,7 @@ describe('lib/middleware/yargsChecksMiddleware', () => {
             getIsInProjectSpy.mockReturnValue(false);
             expect(performChecks(argv)).toBe(true);
             expect(processExitSpy).not.toHaveBeenCalled();
-            expect(logger.error).not.toHaveBeenCalled();
+            expect(uiLogger.error).not.toHaveBeenCalled();
         });
     });
 });

package/lib/middleware/commandTargetingUtils.d.ts

@@ -0,0 +1,8 @@
+type TargetCommandMap = {
+    [key: string]: boolean | TargetCommandMap;
+};
+export declare function isTargetedCommand(commandParts: (string | number)[], targetCommandMap: TargetCommandMap): boolean;
+export declare function shouldLoadConfigForCommand(commandParts: (string | number)[]): boolean;
+export declare function shouldRunAccountValidationForCommand(commandParts: (string | number)[]): boolean;
+export declare function shouldRunConfigValidationForCommand(commandParts: (string | number)[]): boolean;
+export {};

package/lib/middleware/commandTargetingUtils.js

@@ -0,0 +1,78 @@
+import { configFileExists } from '@hubspot/local-dev-lib/config';
+export function isTargetedCommand(commandParts, targetCommandMap) {
+    const currentCommandPart = commandParts[0];
+    if (!targetCommandMap[currentCommandPart]) {
+        return false;
+    }
+    if (typeof targetCommandMap[currentCommandPart] === 'boolean' &&
+        targetCommandMap[currentCommandPart]) {
+        return true;
+    }
+    if (commandParts.length > 1) {
+        const targetSubCommandMap = targetCommandMap[currentCommandPart];
+        if (!targetSubCommandMap) {
+            return false;
+        }
+        return isTargetedCommand(commandParts.slice(1), targetSubCommandMap);
+    }
+    return false;
+}
+const SKIP_CONFIG_LOADING_COMMANDS = {
+    init: true,
+    feedback: true,
+};
+// Returns true if the command requires a config file to be present
+export function shouldLoadConfigForCommand(commandParts) {
+    const globalConfigExists = configFileExists(true);
+    // the user is trying to migrate the global config
+    const isGlobalConfigMigration = !globalConfigExists &&
+        isTargetedCommand(commandParts, {
+            account: { auth: true },
+            config: { migrate: true },
+        });
+    return (!isGlobalConfigMigration &&
+        !isTargetedCommand(commandParts, SKIP_CONFIG_LOADING_COMMANDS));
+}
+const accountsSubCommands = {
+    auth: true,
+    clean: true,
+    list: true,
+    ls: true,
+    remove: true,
+    use: true,
+};
+const sandboxesSubCommands = {
+    delete: true,
+};
+const SKIP_ACCOUNT_VALIDATION_COMMANDS = {
+    init: true,
+    auth: true,
+    mcp: {
+        setup: true,
+        start: true,
+    },
+    account: accountsSubCommands,
+    accounts: accountsSubCommands,
+    sandbox: sandboxesSubCommands,
+    sandboxes: sandboxesSubCommands,
+    config: {
+        migrate: true,
+    },
+    feedback: true,
+};
+// Returns true if the command requires a valid account to be set in the config
+export function shouldRunAccountValidationForCommand(commandParts) {
+    return !isTargetedCommand(commandParts, SKIP_ACCOUNT_VALIDATION_COMMANDS);
+}
+const SKIP_CONFIG_VALIDATION_COMMANDS = {
+    init: true,
+    auth: true,
+    mcp: {
+        setup: true,
+        start: true,
+    },
+};
+// Returns true if the command requires a valid config file to be present
+export function shouldRunConfigValidationForCommand(commandParts) {
+    return !isTargetedCommand(commandParts, SKIP_CONFIG_VALIDATION_COMMANDS);
+}

package/lib/middleware/configMiddleware.d.ts

@@ -9,5 +9,5 @@ export declare function handleDeprecatedEnvVariables(argv: Arguments<{
 export declare function injectAccountIdMiddleware(argv: Arguments<{
     account?: string;
 }>): Promise<void>;
-export declare function loadConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
+export declare function loadAndValidateConfigMiddleware(argv: Arguments<CLIOptions>): Promise<void>;
 export declare function validateAccountOptions(argv: Arguments): Promise<void>;

package/lib/middleware/configMiddleware.js

@@ -1,10 +1,9 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { loadConfig, getAccountId, configFileExists, getConfigPath, validateConfig, } from '@hubspot/local-dev-lib/config';
 import { validateAccount } from '../validation.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
-import { i18n } from '../lang.js';
+import { commands } from '../../lang/en.js';
 import { uiDeprecatedTag } from '../ui/index.js';
-import { isTargetedCommand } from './utils.js';
+import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from './commandTargetingUtils.js';
 import { parseStringToNumber } from '../parsing.js';
 import { uiLogger } from '../ui/logger.js';
 import { lib } from '../../lang/en.js';
@@ -14,9 +13,7 @@ export function handleDeprecatedEnvVariables(argv) {
     if (argv.useEnv &&
         process.env.HUBSPOT_PORTAL_ID &&
         !process.env.HUBSPOT_ACCOUNT_ID) {
-        uiDeprecatedTag(i18n(`commands.generalErrors.handleDeprecatedEnvVariables.portalEnvVarDeprecated`, {
-            configPath: getConfigPath(),
-        }));
+        uiDeprecatedTag(commands.generalErrors.handleDeprecatedEnvVariables.portalEnvVarDeprecated);
         process.env.HUBSPOT_ACCOUNT_ID = process.env.HUBSPOT_PORTAL_ID;
     }
 }
@@ -39,99 +36,42 @@ export async function injectAccountIdMiddleware(argv) {
         argv.derivedAccountId = getAccountId(account);
     }
 }
-const SKIP_CONFIG_VALIDATION = {
-    init: { target: true },
-    auth: { target: true },
-    mcp: {
-        target: false,
-        subCommands: {
-            setup: { target: true },
-            start: { target: true },
-        },
-    },
-};
-export async function loadConfigMiddleware(argv) {
+export async function loadAndValidateConfigMiddleware(argv) {
     // Skip this when no command is provided
     if (!argv._.length || argv.help) {
         return;
     }
-    const maybeValidateConfig = () => {
-        if (!isTargetedCommand(argv._, SKIP_CONFIG_VALIDATION) &&
-            !validateConfig()) {
-            process.exit(EXIT_CODES.ERROR);
-        }
-    };
-    if (!configFileExists(true) &&
-        isTargetedCommand(argv._, {
-            account: { target: false, subCommands: { auth: { target: true } } },
-            config: { target: false, subCommands: { migrate: { target: true } } },
-        })) {
+    // Do not load or validate the config for the commands that do not require it
+    if (!shouldLoadConfigForCommand(argv._)) {
         return;
     }
+    // If the config file exists and the --config flag is used, exit with an error
     if (configFileExists(true) &&
         argv.config &&
-        !isTargetedCommand(argv._, {
-            config: { target: false, subCommands: { migrate: { target: true } } },
-        })) {
-        logger.error(i18n(`commands.generalErrors.loadConfigMiddleware.configFileExists`, {
-            configPath: getConfigPath(),
-        }));
+        !isTargetedCommand(argv._, { config: { migrate: true } })) {
+        uiLogger.error(commands.generalErrors.loadConfigMiddleware.configFileExists(getConfigPath()));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const config = loadConfig(argv.config, argv);
+    // We don't run validation for auth because users should be able to run it when
+    // no accounts are configured, but we still want to exit if the config file is not found
+    if (isTargetedCommand(argv._, { auth: true }) && !config) {
         process.exit(EXIT_CODES.ERROR);
     }
-    else if (!isTargetedCommand(argv._, { init: { target: true } })) {
-        const config = loadConfig(argv.config, argv);
-        // We don't run validateConfig() for auth because users should be able to run it when
-        // no accounts are configured, but we still want to exit if the config file is not found
-        if (isTargetedCommand(argv._, { auth: { target: true } }) && !config) {
+    // Only validate the config if the command requires it
+    if (shouldRunConfigValidationForCommand(argv._)) {
+        const configIsValid = validateConfig();
+        if (!configIsValid) {
             process.exit(EXIT_CODES.ERROR);
         }
     }
-    maybeValidateConfig();
 }
-const accountsSubCommands = {
-    target: false,
-    subCommands: {
-        auth: { target: true },
-        clean: { target: true },
-        list: { target: true },
-        ls: { target: true },
-        remove: { target: true },
-        use: { target: true },
-    },
-};
-const sandboxesSubCommands = {
-    target: false,
-    subCommands: {
-        delete: { target: true },
-    },
-};
-const configSubCommands = {
-    target: false,
-    subCommands: {
-        migrate: { target: true },
-    },
-};
-const SKIP_ACCOUNT_VALIDATION = {
-    init: { target: true },
-    auth: { target: true },
-    mcp: {
-        target: false,
-        subCommands: {
-            setup: { target: true },
-            start: { target: true },
-        },
-    },
-    account: accountsSubCommands,
-    accounts: accountsSubCommands,
-    sandbox: sandboxesSubCommands,
-    sandboxes: sandboxesSubCommands,
-    config: configSubCommands,
-};
 export async function validateAccountOptions(argv) {
     // Skip this when no command is provided
     if (argv._.length && !argv.help) {
         let validAccount = true;
-        if (!isTargetedCommand(argv._, SKIP_ACCOUNT_VALIDATION)) {
+        // Only validate the account if the command requires it
+        if (shouldRunAccountValidationForCommand(argv._)) {
             validAccount = await validateAccount(argv);
         }
         if (!validAccount) {

package/lib/middleware/gitMiddleware.js

@@ -1,8 +1,12 @@
-import { getConfigPath } from '@hubspot/local-dev-lib/config';
+import { getConfigPath, configFileExists } from '@hubspot/local-dev-lib/config';
 import { checkAndWarnGitInclusion } from '../ui/git.js';
 export function checkAndWarnGitInclusionMiddleware(argv) {
     // Skip this when no command is provided
     if (argv._.length) {
+        // Skip if using global config
+        if (configFileExists(true)) {
+            return;
+        }
         const configPath = getConfigPath();
         if (configPath) {
             checkAndWarnGitInclusion(configPath);

package/lib/middleware/notificationsMiddleware.js

@@ -1,8 +1,7 @@
 import updateNotifier from 'update-notifier';
-import chalk from 'chalk';
 import pkg from '../../package.json' with { type: 'json' };
-import { UI_COLORS, uiCommandReference } from '../ui/index.js';
-import { i18n } from '../lang.js';
+import { UI_COLORS } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
 const notifier = updateNotifier({
     pkg: { ...pkg, name: '@hubspot/cli' },
     distTag: 'latest',
@@ -12,13 +11,8 @@ const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
 export function notifyAboutUpdates() {
     notifier.notify({
         message: pkg.name === CMS_CLI_PACKAGE_NAME
-            ? i18n(`commands.generalErrors.updateNotify.cmsUpdateNotification`, {
-                packageName: CMS_CLI_PACKAGE_NAME,
-                updateCommand: uiCommandReference('{updateCommand}'),
-            })
-            : i18n(`commands.generalErrors.updateNotify.cliUpdateNotification`, {
-                updateCommand: uiCommandReference('{updateCommand}'),
-            }),
+            ? lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
+            : lib.middleware.updateNotification.cliUpdateNotification,
         defer: false,
         boxenOptions: {
             borderColor: UI_COLORS.MARIGOLD_DARK,
@@ -28,7 +22,7 @@ export function notifyAboutUpdates() {
             borderStyle: 'round',
             title: pkg.name === CMS_CLI_PACKAGE_NAME
                 ? undefined
-                : chalk.bold(i18n(`commands.generalErrors.updateNotify.notifyTitle`)),
+                : lib.middleware.updateNotification.notifyTitle,
         },
     });
 }

package/lib/middleware/yargsChecksMiddleware.js

@@ -1,20 +1,17 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../ui/logger.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
-import { i18n } from '../lang.js';
+import { commands } from '../../lang/en.js';
 import { getIsInProject } from '../projects/config.js';
-import { isTargetedCommand } from './utils.js';
+import { isTargetedCommand } from './commandTargetingUtils.js';
 const UPLOAD_AND_WATCH_COMMANDS = {
-    upload: { target: true },
-    watch: { target: true },
+    upload: true,
+    watch: true,
 };
 export function performChecks(argv) {
     // Require "project" command when running upload/watch inside of a project
     if (isTargetedCommand(argv._, UPLOAD_AND_WATCH_COMMANDS) &&
         getIsInProject(argv.src)) {
-        logger.error(i18n(`commands.generalErrors.srcIsProject`, {
-            src: argv.src || './',
-            command: argv._.join(' '),
-        }));
+        uiLogger.error(commands.generalErrors.srcIsProject(argv.src || './', argv._.join(' ')));
         process.exit(EXIT_CODES.ERROR);
     }
     return true;

package/lib/npm.js

@@ -1,6 +1,6 @@
 import { exec as execAsync } from 'node:child_process';
 import util from 'util';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import pkg from '../package.json' with { type: 'json' };
 export const DEFAULT_PACKAGE_MANAGER = 'npm';
 export async function isGloballyInstalled(packageName) {
@@ -21,7 +21,7 @@ export async function getLatestCliVersion() {
 }
 export async function executeInstall(packages = [], flags, options) {
     const installCommand = `${DEFAULT_PACKAGE_MANAGER} install${flags ? ` ${flags}` : ''} ${packages.join(' ')}`;
-    logger.debug('Running ', installCommand);
+    uiLogger.debug('Running', installCommand);
     const exec = util.promisify(execAsync);
     await exec(installCommand, options);
 }

package/lib/oauth.js

@@ -5,11 +5,11 @@ import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
 import { handleExit } from './process.js';
-import { i18n } from './lang.js';
+import { lib } from '../lang/en.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
 const PORT = 3000;
 const redirectUri = `http://localhost:${PORT}/oauth-callback`;
@@ -18,7 +18,7 @@ function buildAuthUrl(oauthManager) {
     const env = accountEnv || ENVIRONMENTS.PROD;
     const scopes = accountScopes || DEFAULT_OAUTH_SCOPES;
     if (!clientId) {
-        logger.error(i18n(`lib.oauth.missingClientId`));
+        uiLogger.error(lib.oauth.missingClientId);
         process.exit(EXIT_CODES.ERROR);
     }
     return (`${getHubSpotWebsiteOrigin(env)}/oauth/${oauthManager.account.accountId}/authorize` +
@@ -77,7 +77,7 @@ async function authorize(oauthManager) {
                 reject();
             }
         });
-        server = app.listen(PORT, () => logger.log(`Waiting for authorization...`));
+        server = app.listen(PORT, () => uiLogger.log(`Waiting for authorization...`));
         handleServerOnProcessEnd(server);
     });
 }
@@ -91,7 +91,7 @@ function setupOauth(accountConfig) {
 }
 export async function authenticateWithOauth(accountConfig) {
     const oauthManager = setupOauth(accountConfig);
-    logger.log('Authorizing');
+    uiLogger.log('Authorizing');
     await authorize(oauthManager);
     addOauthToAccountConfig(oauthManager);
 }

package/lib/process.js

@@ -1,6 +1,7 @@
 import readline from 'readline';
-import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
-import { i18n } from './lang.js';
+import { setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
 import { logError } from './errorHandlers/index.js';
 const SIGHUP = 'SIGHUP';
 const uncaughtException = 'uncaughtException';
@@ -26,13 +27,13 @@ export function handleExit(callback) {
                 if (isSIGHUP) {
                     setLogLevel(LOG_LEVEL.NONE);
                 }
-                logger.debug(i18n(`lib.process.exitDebug`, { signal }));
+                uiLogger.debug(lib.process.exitDebug(signal));
                 if (signal === uncaughtException && args && args.length > 0) {
                     try {
                         logError(args[0]);
                     }
                     catch (e) {
-                        logger.error(args[0]);
+                        uiLogger.error(String(args[0]));
                     }
                 }
                 await callback({ isSIGHUP });

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,12 +38,7 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return {
-            ...profile,
-            accountId: process.env.HUBSPOT_ACCOUNT_ID
-                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
-                : profile.accountId,
-        };
+        return profile;
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -59,7 +54,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -68,9 +63,6 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
-        if (useEnv) {
-            return Number(process.env.HUBSPOT_ACCOUNT_ID);
-        }
         return profile.accountId;
     }
     else {