@hubspot/cli 7.10.0-experimental.0 → 7.10.1-experimental.0

package/lang/en.js

@@ -1824,10 +1824,19 @@ export const commands = {
                 default: 'Validate the project before uploading',
             },
             success: (projectName) => `Project ${projectName} is valid and ready to upload`,
-            failure: (projectName) => `Project ${projectName} is invalid`,
+            failure: (projectName, profileName) => `Project ${projectName} is invalid${profileName ? `with profile ${profileName} applied` : ''}`,
+            spinners: {
+                validatingProfile: (profileName) => `Validating project with profile "${profileName}"`,
+                profileValidationFailed: (profileName) => `Profile "${profileName}" failed validation`,
+                profileValidationSucceeded: (profileName) => `Project valid with profile "${profileName}" applied`,
+                invalidWithProfile: (profileName, projectName) => `Project is invalid with profile "${profileName}" applied \n ${commands.project.validate.failure(projectName)}`,
+                validatingAllProfiles: 'Validating the project with all profiles',
+                allProfilesValidationSucceeded: 'Project profile validation succeeded',
+                allProfilesValidationFailed: 'Project profile validation failed',
+            },
             options: {
                 profile: {
-                    describe: 'The profile to target for this validation',
+                    describe: 'The profile to target for this validation.  If no profile is provided, all profiles will be validated.',
                 },
             },
         },
@@ -2866,11 +2875,6 @@ export const lib = {
             startError: (message) => `Failed to start local dev server: ${message}`,
             fileChangeError: (message) => `Failed to notify local dev server of file change: ${message}`,
         },
-        devSession: {
-            registrationError: (message) => `Failed to register dev session: ${message}`,
-            heartbeatError: (message) => `Failed to send dev session heartbeat: ${message}`,
-            deletionError: (message) => `Failed to delete dev session: ${message}`,
-        },
     },
     AppDevModeInterface: {
         autoInstallStaticAuthApp: {
@@ -2983,7 +2987,7 @@ export const lib = {
         updateNotification: {
             notifyTitle: chalk.bold('CLI update available'),
             cmsUpdateNotification: (packageName) => `${chalk.bold('The CMS CLI is now the HubSpot CLI')}\n\nTo upgrade, uninstall ${chalk.bold(packageName)}\nand then run ${uiCommandReference('{updateCommand}')}`,
-            cliUpdateNotification: `HubSpot CLI version ${chalk.cyan(chalk.bold('{currentVersion}'))} is outdated.\nRun ${uiCommandReference('{updateCommand}')} to upgrade to version ${chalk.cyan(chalk.bold('{latestVersion}'))}`,
+            cliUpdateNotification: (currentVersion, updateCommand, latestVersion) => `HubSpot CLI version ${chalk.cyan(chalk.bold(`${currentVersion}`))} is outdated.\nRun ${uiCommandReference(`${updateCommand}`)} to upgrade to version ${chalk.cyan(chalk.bold(`${latestVersion}`))}`,
         },
         autoUpdateCLI: {
             updateAvailable: (latestVersion) => `There's a new HubSpot CLI version available! Updating to version ${chalk.bold(latestVersion)}`,
@@ -3008,7 +3012,9 @@ export const lib = {
                 noProjectConfig: 'No project config found. Please run this command from a project directory.',
                 profileNotFound: (profileName) => `Profile ${chalk.bold(profileName)} not found.`,
                 missingAccountId: (profileName) => `Profile ${chalk.bold(profileName)} is missing an account id.`,
+                listedAccountNotFound: (accountId, profileName) => `The account ${uiAccountDescription(accountId)} is defined in your profile ${chalk.bold(profileName)}, but is missing in your config file`,
                 failedToLoadProfile: (profileName) => `Failed to load profile ${chalk.bold(profileName)}.`,
+                profileNotValid: (profileName, errors) => `Profile "${profileName}" is not valid:\n\t- ${errors.join('\n\t- ')}`,
             },
         },
     },
@@ -3099,9 +3105,6 @@ export const lib = {
             legacyFileDetected: (filename, platformVersion) => `The ${chalk.bold(filename)} file is not supported on platform version ${chalk.bold(platformVersion)} and will be ignored.`,
         },
     },
-    boxen: {
-        failedToLoad: 'Failed to load boxen util.',
-    },
     importData: {
         errors: {
             incorrectAccountType: (derivedAccountId) => `The account ${uiAccountDescription(derivedAccountId)} is not a standard account, developer test account, or app developer account.`,

package/lib/__tests__/projectProfiles.test.js

@@ -1,22 +1,26 @@
 import path from 'path';
-import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, validateProfileVariables, } from '@hubspot/project-parsing-lib';
 import { lib } from '../../lang/en.js';
 import { uiBetaTag, uiLine } from '../ui/index.js';
 import { uiLogger } from '../ui/logger.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.js';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { logProfileHeader, logProfileFooter, loadProfile, enforceProfileUsage, loadAndValidateProfile, validateProjectForProfile, } from '../projectProfiles.js';
+import { handleTranslate } from '../projects/upload.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { commands } from '../../lang/en.js';
 // Mock dependencies
 vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../ui');
 vi.mock('../ui/logger');
 vi.mock('../../lang/en');
-// Mock process.exit
-const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
-    throw new Error(`Process.exit called with code ${code}`);
-});
+vi.mock('../projects/upload');
+vi.mock('../ui/SpinniesManager');
 const mockedLoadHsProfileFile = loadHsProfileFile;
 const mockedGetHsProfileFilename = getHsProfileFilename;
 const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedValidateProfileVariables = validateProfileVariables;
+const mockedGetConfigAccountById = getConfigAccountById;
 const mockedUiBetaTag = uiBetaTag;
 const mockedUiLine = uiLine;
 const mockedUiLogger = uiLogger;
@@ -68,62 +72,299 @@ describe('lib/projectProfiles', () => {
         const mockProfile = {
             accountId: 123,
         };
-        it('should return undefined when project config is missing', () => {
-            const result = loadProfile(null, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should throw error when project config is missing', () => {
+            expect(() => loadProfile(null, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
         });
-        it('should return undefined when profile is not found', () => {
+        it('should throw error when project dir is missing', () => {
+            expect(() => loadProfile(mockProjectConfig, null, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        });
+        it('should throw error when profile is not found', () => {
             mockedLoadHsProfileFile.mockReturnValue(null);
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
         });
-        it('should return undefined when profile has no account ID', () => {
+        it('should throw error when profile has no account ID', () => {
             mockedLoadHsProfileFile.mockReturnValue({});
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
         });
-        it('should return undefined when profile loading fails', () => {
+        it('should throw error when profile loading fails', () => {
             mockedLoadHsProfileFile.mockImplementation(() => {
                 throw new Error('Load failed');
             });
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
-            expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+        });
+        it('should throw error when account is not found in config', () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockImplementation(() => {
+                throw new Error('Account not found');
+            });
+            const filename = 'test-profile.hsprofile';
+            mockedGetHsProfileFilename.mockReturnValue(filename);
+            expect(() => loadProfile(mockProjectConfig, mockProjectDir, mockProfileName)).toThrow(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(mockProfile.accountId, filename));
         });
         it('should return profile when loading succeeds', () => {
             mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
             const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toEqual(mockProfile);
             expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedGetConfigAccountById).toHaveBeenCalledWith(mockProfile.accountId);
         });
     });
-    describe('exitIfUsingProfiles()', () => {
+    describe('enforceProfileUsage()', () => {
         const mockProjectConfig = {
             srcDir: 'src',
             name: 'test-project',
             platformVersion: '1.0.0',
         };
         const mockProjectDir = '/test/project';
-        it('should not exit when no profiles exist', async () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should not throw when no profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue([]);
-            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
-            expect(mockedUiLogger.error).not.toHaveBeenCalled();
-            expect(mockExit).not.toHaveBeenCalled();
+            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).resolves.toBeUndefined();
         });
-        it('should exit with error when profiles exist', async () => {
+        it('should throw error when profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
-            await expect(exitIfUsingProfiles(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${EXIT_CODES.ERROR}`);
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(enforceProfileUsage(mockProjectConfig, mockProjectDir)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+        });
+        it('should not throw when project config is null', async () => {
+            await expect(enforceProfileUsage(null, mockProjectDir)).resolves.toBeUndefined();
+        });
+        it('should not throw when project dir is null', async () => {
+            await expect(enforceProfileUsage(mockProjectConfig, null)).resolves.toBeUndefined();
+        });
+    });
+    describe('loadAndValidateProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '1.0.0',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockProfile = {
+            accountId: 123,
+            variables: {
+                key1: 'value1',
+                key2: 'value2',
+            },
+        };
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should enforce profile usage when no profile name provided', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined);
+            expect(result).toBeUndefined();
+            expect(mockedGetAllHsProfiles).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir));
+        });
+        it('should throw when profiles exist but no profile name provided', async () => {
+            mockedGetAllHsProfiles.mockResolvedValue(['profile1']);
+            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, undefined)).rejects.toThrow(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+        });
+        it('should load and return account ID when profile is valid', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBe(mockProfile.accountId);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedValidateProfileVariables).toHaveBeenCalledWith(mockProfile.variables, mockProfileName);
+        });
+        it('should log profile header and footer when not silent', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, false);
+            expect(mockedUiBetaTag).toHaveBeenCalled();
+            expect(mockedUiLine).toHaveBeenCalled();
+            expect(mockedUiLogger.log).toHaveBeenCalled();
+        });
+        it('should not log when silent is true', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockProfile.accountId,
+            });
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName, true);
+            expect(mockedUiBetaTag).not.toHaveBeenCalled();
+            expect(mockedUiLine).not.toHaveBeenCalled();
+        });
+        it('should throw error when profile variables are invalid', async () => {
+            const invalidProfile = {
+                accountId: 123,
+                variables: {
+                    invalid: 'value',
+                },
+            };
+            const validationErrors = ['Variable "invalid" is not allowed'];
+            mockedLoadHsProfileFile.mockReturnValue(invalidProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: invalidProfile.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            mockedValidateProfileVariables.mockReturnValue({
+                success: false,
+                errors: validationErrors,
+            });
+            await expect(loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName)).rejects.toThrow(lib.projectProfiles.loadProfile.errors.profileNotValid('test-profile.hsprofile', validationErrors));
+        });
+        it('should not validate when profile has no variables', async () => {
+            const profileWithoutVars = {
+                accountId: 123,
+            };
+            mockedLoadHsProfileFile.mockReturnValue(profileWithoutVars);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: profileWithoutVars.accountId,
+            });
+            mockedGetHsProfileFilename.mockReturnValue('test-profile.hsprofile');
+            const result = await loadAndValidateProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            expect(result).toBe(profileWithoutVars.accountId);
+            expect(mockedValidateProfileVariables).not.toHaveBeenCalled();
+        });
+    });
+    describe('validateProjectForProfile()', () => {
+        const mockProjectConfig = {
+            srcDir: 'src',
+            name: 'test-project',
+            platformVersion: '2025.2',
+        };
+        const mockProjectDir = '/test/project';
+        const mockProfileName = 'test-profile';
+        const mockDerivedAccountId = 123;
+        const mockProfileFilename = 'test-profile.hsprofile';
+        const mockProfile = {
+            accountId: mockDerivedAccountId,
+        };
+        beforeEach(() => {
+            vi.clearAllMocks();
+            mockedGetHsProfileFilename.mockReturnValue(mockProfileFilename);
+            vi.mocked(SpinniesManager.init);
+            vi.mocked(SpinniesManager.add);
+            vi.mocked(SpinniesManager.succeed);
+            vi.mocked(SpinniesManager.fail);
+            // Mock dependencies for loadAndValidateProfile
+            mockedGetAllHsProfiles.mockResolvedValue([]);
+            mockedLoadHsProfileFile.mockReturnValue(mockProfile);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: mockDerivedAccountId,
+            });
+            mockedValidateProfileVariables.mockReturnValue({ success: true });
+            vi.mocked(handleTranslate).mockResolvedValue(undefined);
+        });
+        it('should return empty array when validation succeeds', async () => {
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result).toEqual([]);
+            expect(SpinniesManager.init).toHaveBeenCalled();
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 0,
+            });
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationSucceeded(mockProfileFilename),
+            });
+        });
+        it('should call handleTranslate with profile account ID from profile', async () => {
+            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(handleTranslate).toHaveBeenCalledWith(mockProjectDir, mockProjectConfig, mockDerivedAccountId, false, mockProfileName);
+        });
+        it('should call handleTranslate with different profile account ID when profile has different ID', async () => {
+            const profileAccountId = 456;
+            const profileWithDifferentId = {
+                accountId: profileAccountId,
+            };
+            mockedLoadHsProfileFile.mockReturnValue(profileWithDifferentId);
+            mockedGetConfigAccountById.mockReturnValue({
+                accountId: profileAccountId,
+            });
+            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(handleTranslate).toHaveBeenCalledWith(mockProjectDir, mockProjectConfig, profileAccountId, false, mockProfileName);
+        });
+        it('should return error when profile has no accountId', async () => {
+            // @ts-expect-error causing an error on purpose
+            const profileWithoutId = {};
+            mockedLoadHsProfileFile.mockReturnValue(profileWithoutId);
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalled();
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should indent spinners when indentSpinners is true', async () => {
+            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId, true);
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 4,
+            });
+        });
+        it('should not indent spinners when indentSpinners is false', async () => {
+            await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId, false);
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.validatingProfile(mockProfileFilename),
+                indent: 0,
+            });
+        });
+        it('should return error array when profile loading fails', async () => {
+            mockedLoadHsProfileFile.mockReturnValue(null);
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
+            });
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should return error when profile file loading throws', async () => {
+            mockedLoadHsProfileFile.mockImplementation(() => {
+                throw new Error('Failed to load profile file');
+            });
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result.length).toBeGreaterThan(0);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.profileValidationFailed(mockProfileFilename),
+            });
+            expect(handleTranslate).not.toHaveBeenCalled();
+        });
+        it('should return error array when translation fails', async () => {
+            const error = new Error('Translation failed');
+            vi.mocked(handleTranslate).mockRejectedValue(error);
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBe(commands.project.validate.failure(mockProjectConfig.name));
+            expect(result[1]).toBe(error);
+            expect(SpinniesManager.fail).toHaveBeenCalledWith(`validatingProfile-${mockProfileName}`, {
+                text: commands.project.validate.spinners.invalidWithProfile(mockProfileFilename, mockProjectConfig.name),
+            });
+        });
+        it('should return string error when translation fails with non-Error', async () => {
+            const error = 'Translation error';
+            vi.mocked(handleTranslate).mockRejectedValue(error);
+            const result = await validateProjectForProfile(mockProjectConfig, mockProjectDir, mockProfileName, mockDerivedAccountId);
+            expect(result).toHaveLength(2);
+            expect(result[0]).toBe(commands.project.validate.failure(mockProjectConfig.name));
+            expect(result[1]).toBe(error);
+        });
+        it('should use correct spinner name based on profile name', async () => {
+            const customProfileName = 'custom-profile';
+            await validateProjectForProfile(mockProjectConfig, mockProjectDir, customProfileName, mockDerivedAccountId);
+            expect(SpinniesManager.add).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
+            expect(SpinniesManager.succeed).toHaveBeenCalledWith(`validatingProfile-${customProfileName}`, expect.any(Object));
         });
     });
 });

package/lib/middleware/autoUpdateMiddleware.js

@@ -1,13 +1,14 @@
 import updateNotifier from 'update-notifier';
 import { getConfig } from '@hubspot/local-dev-lib/config';
 import { pkg } from '../jsonLoader.js';
-import { UI_COLORS } from '../ui/index.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { lib } from '../../lang/en.js';
 import { DEFAULT_PACKAGE_MANAGER, isGloballyInstalled, executeInstall, } from '../npm.js';
 import { debugError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { isTargetedCommand } from './commandTargetingUtils.js';
+import { renderInline } from '../../ui/index.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 // Default behavior is to check for notifications at most once per day
 // update-notifier stores the last checked date in the user's home directory
 const notifier = updateNotifier({
@@ -16,24 +17,16 @@ const notifier = updateNotifier({
     shouldNotifyInNpmScript: true,
 });
 const CMS_CLI_PACKAGE_NAME = '@hubspot/cms-cli';
-async function updateNotification() {
-    notifier.notify({
+async function updateNotification(currentVersion, latestVersion, updateCommand) {
+    await renderInline(getWarningBox({
+        title: pkg.name === CMS_CLI_PACKAGE_NAME
+            ? ''
+            : lib.middleware.updateNotification.notifyTitle,
         message: pkg.name === CMS_CLI_PACKAGE_NAME
             ? lib.middleware.updateNotification.cmsUpdateNotification(CMS_CLI_PACKAGE_NAME)
-            : lib.middleware.updateNotification.cliUpdateNotification,
-        defer: false,
-        boxenOptions: {
-            borderColor: UI_COLORS.MARIGOLD_DARK,
-            margin: 1,
-            padding: 1,
-            textAlignment: 'center',
-            borderStyle: 'round',
-            title: pkg.name === CMS_CLI_PACKAGE_NAME
-                ? undefined
-                : lib.middleware.updateNotification.notifyTitle,
-        },
-        isGlobal: await isGloballyInstalled('hs'),
-    });
+            : lib.middleware.updateNotification.cliUpdateNotification(currentVersion, updateCommand, latestVersion),
+        textCentered: true,
+    }));
 }
 const SKIP_AUTO_UPDATE_COMMANDS = {
     config: {
@@ -44,8 +37,16 @@ const preventAutoUpdateForCommand = (commandParts) => {
     return isTargetedCommand(commandParts, SKIP_AUTO_UPDATE_COMMANDS);
 };
 export async function autoUpdateCLI(argv) {
-    // This lets us back to default update-notifier behavior
     let showManualInstallHelp = true;
+    let isGlobalInstall = null;
+    const checkGlobalInstall = async () => {
+        if (isGlobalInstall === null) {
+            isGlobalInstall =
+                (await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER)) &&
+                    (await isGloballyInstalled('hs'));
+        }
+        return isGlobalInstall;
+    };
     let config;
     try {
         config = getConfig();
@@ -71,8 +72,7 @@ export async function autoUpdateCLI(argv) {
                     text: lib.middleware.autoUpdateCLI.updateAvailable(notifier.update.latest),
                 });
                 try {
-                    if ((await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER)) &&
-                        (await isGloballyInstalled('hs'))) {
+                    if (await checkGlobalInstall()) {
                         await executeInstall(['@hubspot/cli@latest'], '-g');
                         showManualInstallHelp = false;
                         SpinniesManager.succeed('cliAutoUpdate', {
@@ -95,7 +95,10 @@ export async function autoUpdateCLI(argv) {
             }
         }
     }
-    if (showManualInstallHelp) {
-        await updateNotification();
+    if (showManualInstallHelp &&
+        notifier.update &&
+        process.stdout.isTTY &&
+        !notifier.update.current.includes('-')) {
+        await updateNotification(notifier.update.current, notifier.update.latest, `npm i ${(await checkGlobalInstall()) ? '-g' : ''} @hubspot/cli`);
     }
 }

package/lib/middleware/fireAlarmMiddleware.js

@@ -2,7 +2,6 @@ import chalk from 'chalk';
 import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
 import { debugError } from '../errorHandlers/index.js';
 import { pkg } from '../jsonLoader.js';
-import { logInBox } from '../ui/boxen.js';
 import { renderInline } from '../../ui/index.js';
 import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 /*
@@ -100,20 +99,10 @@ async function logFireAlarms(accountId, command, version) {
             }
             return acc;
         }, '');
-        if (!process.env.HUBSPOT_ENABLE_INK) {
-            await logInBox({
-                contents: notifications,
-                options: {
-                    title: 'Notifications',
-                },
-            });
-        }
-        else {
-            await renderInline(getWarningBox({
-                title: 'Notifications',
-                message: notifications,
-            }));
-        }
+        await renderInline(getWarningBox({
+            title: 'Notifications',
+            message: notifications,
+        }));
     }
 }
 export async function checkFireAlarms(argv) {

package/lib/projectProfiles.d.ts

@@ -2,6 +2,7 @@ import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { ProjectConfig } from '../types/Projects.js';
 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): Promise<number | undefined>;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
+export declare function enforceProfileUsage(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string | undefined, silent?: boolean): Promise<number | undefined>;
+export declare function validateProjectForProfile(projectConfig: ProjectConfig, projectDir: string, profileName: string, derivedAccountId: number, indentSpinners?: boolean): Promise<(string | Error)[]>;