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

package/commands/project/__tests__/validate.test.js

@@ -5,11 +5,14 @@ import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/
 import { uiLogger } from '../../../lib/ui/logger.js';
 import { commands } from '../../../lang/en.js';
 import { isV2Project } from '../../../lib/projects/platformVersion.js';
-import { loadAndValidateProfile } from '../../../lib/projectProfiles.js';
+import { validateProjectForProfile } from '../../../lib/projectProfiles.js';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { handleTranslate } from '../../../lib/projects/upload.js';
 import projectValidateCommand from '../validate.js';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
+import SpinniesManager from '../../../lib/ui/SpinniesManager.js';
+import { logError } from '../../../lib/errorHandlers/index.js';
 // Mock dependencies
 vi.mock('../../../lib/projects/upload.js');
 vi.mock('../../../lib/projects/config.js');
@@ -19,15 +22,35 @@ vi.mock('../../../lib/projectProfiles.js');
 vi.mock('../../../lib/errorHandlers/index.js');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/projects/platformVersion.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../../../lib/ui/SpinniesManager.js');
 describe('commands/project/validate', () => {
     const projectDir = '/test/project';
     let exitSpy;
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: '2025.2',
+    };
+    const mockAccountConfig = {
+        accountType: 'STANDARD',
+        accountId: 123,
+        env: 'prod',
+    };
     beforeEach(() => {
         // Mock process.exit to throw to stop execution
         exitSpy = vi.spyOn(process, 'exit').mockImplementation(code => {
             throw new Error(`Process exited with code ${code}`);
         });
         vi.clearAllMocks();
+        // Set up default mocks
+        vi.mocked(getConfigAccountById).mockReturnValue(mockAccountConfig);
+        vi.mocked(trackCommandUsage);
+        vi.mocked(SpinniesManager.init);
+        vi.mocked(SpinniesManager.add);
+        vi.mocked(SpinniesManager.succeed);
+        vi.mocked(SpinniesManager.fail);
+        vi.mocked(validateProjectForProfile).mockResolvedValue([]);
     });
     afterEach(() => {
         exitSpy.mockRestore();
@@ -65,34 +88,269 @@ describe('commands/project/validate', () => {
             })).rejects.toThrow('Process exited with code 1');
             expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.mustBeRanWithinAProject);
         });
+        it('should exit with error for non-V2 projects', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: {
+                    name: 'test',
+                    srcDir: 'src',
+                    platformVersion: '2024.1',
+                },
+                projectDir,
+            });
+            vi.mocked(isV2Project).mockReturnValue(false);
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.badVersion);
+        });
+        it('should exit with error when validateProjectConfig throws', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir,
+            });
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const error = new Error('Invalid project config');
+            vi.mocked(validateProjectConfig).mockImplementation(() => {
+                throw error;
+            });
+            await expect(
+            // @ts-expect-error partial mock
+            projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(logError).toHaveBeenCalledWith(error);
+        });
     });
-    it('should call validateSourceDirectory with correct parameters', async () => {
-        const mockProjectConfig = {
-            name: 'test-project',
-            srcDir: 'src',
-            platformVersion: '2025.2',
-        };
-        vi.mocked(getProjectConfig).mockResolvedValue({
-            projectConfig: mockProjectConfig,
-            projectDir,
+    describe('profile validation', () => {
+        describe('when a specific profile is provided', () => {
+            it('should validate only the specified profile', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod', 'qa']);
+                vi.mocked(validateProjectForProfile).mockResolvedValue([]);
+                vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    profile: 'dev',
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 0');
+                // Should call validateProjectForProfile for the specified profile
+                expect(validateProjectForProfile).toHaveBeenCalledWith(mockProjectConfig, projectDir, 'dev', 123);
+                expect(uiLogger.success).toHaveBeenCalledWith(commands.project.validate.success(mockProjectConfig.name));
+            });
+            it('should handle profile validation failure', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod']);
+                const error = new Error('Profile not found');
+                vi.mocked(validateProjectForProfile).mockResolvedValue([error.message]);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    profile: 'dev',
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 1');
+                // The error message is logged as a string, not the Error object
+                expect(uiLogger.error).toHaveBeenCalledWith(error.message);
+            });
+            it('should handle translate failure for a profile', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod']);
+                const error = new Error('Translation failed');
+                vi.mocked(validateProjectForProfile).mockResolvedValue([
+                    commands.project.validate.failure(mockProjectConfig.name),
+                    error,
+                ]);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    profile: 'dev',
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 1');
+                // The error object is logged via logError
+                expect(logError).toHaveBeenCalledWith(error);
+            });
         });
-        vi.mocked(isV2Project).mockReturnValue(true);
-        vi.mocked(validateProjectConfig).mockReturnValue(undefined);
-        vi.mocked(loadAndValidateProfile).mockResolvedValue(123);
-        vi.mocked(getConfigAccountById).mockReturnValue({
-            accountType: 'STANDARD',
-            accountId: 123,
-            env: 'prod',
+        describe('when no profile is provided and project has profiles', () => {
+            it('should validate all profiles', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod', 'qa']);
+                vi.mocked(validateProjectForProfile).mockResolvedValue([]);
+                vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 0');
+                // Should validate all three profiles
+                expect(validateProjectForProfile).toHaveBeenCalledTimes(3);
+                expect(validateProjectForProfile).toHaveBeenCalledWith(mockProjectConfig, projectDir, 'dev', 123, true);
+                expect(validateProjectForProfile).toHaveBeenCalledWith(mockProjectConfig, projectDir, 'prod', 123, true);
+                expect(validateProjectForProfile).toHaveBeenCalledWith(mockProjectConfig, projectDir, 'qa', 123, true);
+                // Should show success for all profiles
+                expect(SpinniesManager.succeed).toHaveBeenCalledWith('validatingAllProfiles', expect.any(Object));
+                expect(uiLogger.success).toHaveBeenCalledWith(commands.project.validate.success(mockProjectConfig.name));
+            });
+            it('should handle failure when validating multiple profiles', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod']);
+                vi.mocked(validateProjectForProfile)
+                    .mockResolvedValueOnce([]) // dev succeeds
+                    .mockResolvedValueOnce(['Profile not found']); // prod fails
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 1');
+                expect(SpinniesManager.fail).toHaveBeenCalledWith('validatingAllProfiles', expect.any(Object));
+            });
+            it('should continue validating remaining profiles after one fails', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue(['dev', 'prod', 'qa']);
+                vi.mocked(validateProjectForProfile)
+                    .mockResolvedValueOnce([]) // dev succeeds
+                    .mockResolvedValueOnce(['Profile not found']) // prod fails
+                    .mockResolvedValueOnce([]); // qa succeeds
+                vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 1');
+                // All three profiles should be attempted
+                expect(validateProjectForProfile).toHaveBeenCalledTimes(3);
+            });
+        });
+        describe('when no profile is provided and project has no profiles', () => {
+            it('should validate without a profile', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue([]);
+                vi.mocked(handleTranslate).mockResolvedValue(undefined);
+                vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 0');
+                // Should call handleTranslate without a profile
+                expect(handleTranslate).toHaveBeenCalledWith(projectDir, mockProjectConfig, 123, false, undefined);
+                expect(uiLogger.success).toHaveBeenCalledWith(commands.project.validate.success(mockProjectConfig.name));
+            });
+            it('should handle validation failure when no profiles exist', async () => {
+                vi.mocked(getProjectConfig).mockResolvedValue({
+                    projectConfig: mockProjectConfig,
+                    projectDir,
+                });
+                vi.mocked(isV2Project).mockReturnValue(true);
+                vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+                vi.mocked(getAllHsProfiles).mockResolvedValue([]);
+                const error = new Error('Translation failed');
+                vi.mocked(handleTranslate).mockRejectedValue(error);
+                await expect(projectValidateCommand.handler({
+                    derivedAccountId: 123,
+                    d: false,
+                    debug: false,
+                })).rejects.toThrow('Process exited with code 1');
+                expect(uiLogger.error).toHaveBeenCalledWith(commands.project.validate.failure(mockProjectConfig.name));
+                expect(logError).toHaveBeenCalledWith(error);
+            });
+        });
+    });
+    describe('source directory validation', () => {
+        it('should call validateSourceDirectory with correct parameters', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir,
+            });
+            vi.mocked(isV2Project).mockReturnValue(true);
+            vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+            vi.mocked(getAllHsProfiles).mockResolvedValue([]);
+            vi.mocked(handleTranslate).mockResolvedValue(undefined);
+            vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+            await expect(projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 0');
+            const expectedSrcDir = path.resolve(projectDir, mockProjectConfig.srcDir);
+            expect(validateSourceDirectory).toHaveBeenCalledWith(expectedSrcDir, mockProjectConfig, projectDir);
+        });
+        it('should exit with error when validateSourceDirectory throws', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir,
+            });
+            vi.mocked(isV2Project).mockReturnValue(true);
+            vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+            vi.mocked(getAllHsProfiles).mockResolvedValue([]);
+            vi.mocked(handleTranslate).mockResolvedValue(undefined);
+            const error = new Error('Invalid source directory');
+            vi.mocked(validateSourceDirectory).mockRejectedValue(error);
+            await expect(projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 1');
+            expect(logError).toHaveBeenCalledWith(error);
+        });
+    });
+    describe('command usage tracking', () => {
+        it('should track command usage with account type', async () => {
+            vi.mocked(getProjectConfig).mockResolvedValue({
+                projectConfig: mockProjectConfig,
+                projectDir,
+            });
+            vi.mocked(isV2Project).mockReturnValue(true);
+            vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+            vi.mocked(getAllHsProfiles).mockResolvedValue([]);
+            vi.mocked(handleTranslate).mockResolvedValue(undefined);
+            vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
+            await expect(projectValidateCommand.handler({
+                derivedAccountId: 123,
+                d: false,
+                debug: false,
+            })).rejects.toThrow('Process exited with code 0');
+            expect(trackCommandUsage).toHaveBeenCalledWith('project-validate', { type: 'STANDARD' }, 123);
         });
-        vi.mocked(trackCommandUsage);
-        vi.mocked(validateSourceDirectory).mockResolvedValue(undefined);
-        vi.mocked(handleTranslate).mockResolvedValue(undefined);
-        await expect(projectValidateCommand.handler({
-            derivedAccountId: 123,
-            d: false,
-            debug: false,
-        })).rejects.toThrow('Process exited with code 0');
-        const expectedSrcDir = path.resolve(projectDir, mockProjectConfig.srcDir);
-        expect(validateSourceDirectory).toHaveBeenCalledWith(expectedSrcDir, mockProjectConfig, projectDir);
     });
 });

package/commands/project/deploy.js

@@ -7,11 +7,10 @@ import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
 import { getProjectConfig } from '../../lib/projects/config.js';
 import { projectNamePrompt } from '../../lib/prompts/projectNamePrompt.js';
 import { promptUser } from '../../lib/prompts/promptUtils.js';
-import { uiLine } from '../../lib/ui/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { loadProfile, logProfileFooter, logProfileHeader, exitIfUsingProfiles, } from '../../lib/projectProfiles.js';
+import { loadProfile, logProfileFooter, logProfileHeader, enforceProfileUsage, } from '../../lib/projectProfiles.js';
 import { PROJECT_DEPLOY_TEXT } from '../../lib/constants.js';
 import { commands } from '../../lang/en.js';
 import { handleProjectDeploy, validateBuildIdForDeploy, logDeployErrors, } from '../../lib/projects/deploy.js';
@@ -27,9 +26,12 @@ async function handler(args) {
     if (isV2Project(projectConfig?.platformVersion)) {
         if (args.profile) {
             logProfileHeader(args.profile);
-            const profile = loadProfile(projectConfig, projectDir, args.profile);
-            if (!profile) {
-                uiLine();
+            let profile;
+            try {
+                profile = loadProfile(projectConfig, projectDir, args.profile);
+            }
+            catch (error) {
+                logError(error);
                 process.exit(EXIT_CODES.ERROR);
             }
             targetAccountId = profile.accountId;
@@ -37,7 +39,13 @@ async function handler(args) {
         }
         else {
             // A profile must be specified if this project has profiles configured
-            await exitIfUsingProfiles(projectConfig, projectDir);
+            try {
+                await enforceProfileUsage(projectConfig, projectDir);
+            }
+            catch (error) {
+                logError(error);
+                process.exit(EXIT_CODES.ERROR);
+            }
         }
     }
     if (!targetAccountId) {

package/commands/project/dev/index.js

@@ -7,7 +7,7 @@ import { deprecatedProjectDevFlow } from './deprecatedFlow.js';
 import { unifiedProjectDevFlow } from './unifiedFlow.js';
 import { isV2Project } from '../../../lib/projects/platformVersion.js';
 import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
-import { loadProfile, exitIfUsingProfiles, } from '../../../lib/projectProfiles.js';
+import { loadProfile, enforceProfileUsage, } from '../../../lib/projectProfiles.js';
 import { commands } from '../../../lang/en.js';
 import { uiLogger } from '../../../lib/ui/logger.js';
 import { logError } from '../../../lib/errorHandlers/index.js';
@@ -64,8 +64,11 @@ async function handler(args) {
     }
     if (!targetProjectAccountId && isV2Project(projectConfig.platformVersion)) {
         if (args.profile) {
-            profile = loadProfile(projectConfig, projectDir, args.profile);
-            if (!profile) {
+            try {
+                profile = loadProfile(projectConfig, projectDir, args.profile);
+            }
+            catch (error) {
+                logError(error);
                 uiLine();
                 process.exit(EXIT_CODES.ERROR);
             }
@@ -75,7 +78,13 @@ async function handler(args) {
         }
         else {
             // A profile must be specified if this project has profiles configured
-            await exitIfUsingProfiles(projectConfig, projectDir);
+            try {
+                await enforceProfileUsage(projectConfig, projectDir);
+            }
+            catch (error) {
+                logError(error);
+                process.exit(EXIT_CODES.ERROR);
+            }
         }
     }
     if (!targetProjectAccountId) {

package/commands/project/migrate.js

@@ -7,7 +7,6 @@ import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { uiCommandReference } from '../../lib/ui/index.js';
 import { commands, lib } from '../../lang/en.js';
 import { uiLogger } from '../../lib/ui/logger.js';
-import { logInBox } from '../../lib/ui/boxen.js';
 import { renderInline } from '../../ui/index.js';
 import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 import { getHasMigratableThemes, migrateThemes2025_2, } from '../../lib/theme/migrate.js';
@@ -26,18 +25,10 @@ async function handler(args) {
         return process.exit(EXIT_CODES.ERROR);
     }
     if (projectConfig?.projectConfig) {
-        if (!process.env.HUBSPOT_ENABLE_INK) {
-            await logInBox({
-                contents: lib.migrate.projectMigrationWarning,
-                options: { title: lib.migrate.projectMigrationWarningTitle },
-            });
-        }
-        else {
-            await renderInline(getWarningBox({
-                title: lib.migrate.projectMigrationWarningTitle,
-                message: lib.migrate.projectMigrationWarning,
-            }));
-        }
+        await renderInline(getWarningBox({
+            title: lib.migrate.projectMigrationWarningTitle,
+            message: lib.migrate.projectMigrationWarning,
+        }));
     }
     try {
         const { hasMigratableThemes, migratableThemesCount } = await getHasMigratableThemes(projectConfig);

package/commands/project/upload.js

@@ -28,8 +28,14 @@ async function handler(args) {
         process.exit(EXIT_CODES.ERROR);
     }
     let targetAccountId;
-    if (isV2Project(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+    try {
+        if (isV2Project(projectConfig.platformVersion)) {
+            targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
+        }
+    }
+    catch (err) {
+        logError(err);
+        process.exit(EXIT_CODES.ERROR);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getConfigAccountById(targetAccountId);

package/commands/project/validate.js

@@ -8,13 +8,19 @@ import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
 import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
 import { commands } from '../../lang/en.js';
-import { loadAndValidateProfile } from '../../lib/projectProfiles.js';
+import { validateProjectForProfile } from '../../lib/projectProfiles.js';
 import { logError } from '../../lib/errorHandlers/index.js';
+import { getAllHsProfiles } from '@hubspot/project-parsing-lib';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 const command = 'validate';
 const describe = commands.project.validate.describe;
 async function handler(args) {
+    SpinniesManager.init();
     const { derivedAccountId, profile } = args;
     const { projectConfig, projectDir } = await getProjectConfig();
+    const accountConfig = getConfigAccountById(derivedAccountId);
+    const accountType = accountConfig && accountConfig.accountType;
+    trackCommandUsage('project-validate', { type: accountType }, derivedAccountId);
     if (!projectConfig || !projectDir) {
         uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
         process.exit(EXIT_CODES.ERROR);
@@ -30,25 +36,79 @@ async function handler(args) {
         logError(error);
         process.exit(EXIT_CODES.ERROR);
     }
-    let targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
-    targetAccountId = targetAccountId || derivedAccountId;
-    const accountConfig = getConfigAccountById(targetAccountId);
-    const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-validate', { type: accountType }, targetAccountId);
+    let validationSucceeded = true;
     const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
+    // Get all of the profiles except the provided profile
+    const profiles = (await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir))).filter(profileName => profileName !== profile);
+    // If a profile is specified, only validate that profile
+    if (profile) {
+        const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profile, derivedAccountId);
+        if (validationErrors.length) {
+            validationErrors.forEach(error => {
+                uiLogger.log('');
+                if (error instanceof Error) {
+                    logError(error);
+                }
+                else {
+                    uiLogger.error(error);
+                }
+            });
+            validationSucceeded = false;
+        }
     }
-    catch (e) {
-        logError(e);
+    else if (profiles.length > 0) {
+        // If no profile was specified and the project has profiles, validate all of them
+        SpinniesManager.add('validatingAllProfiles', {
+            text: commands.project.validate.spinners.validatingAllProfiles,
+        });
+        const errors = [];
+        for (const profileName of profiles) {
+            const validationErrors = await validateProjectForProfile(projectConfig, projectDir, profileName, derivedAccountId, true);
+            if (validationErrors.length) {
+                errors.push(...validationErrors);
+                validationSucceeded = false;
+            }
+        }
+        if (validationSucceeded) {
+            SpinniesManager.succeed('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
+            });
+        }
+        else {
+            SpinniesManager.fail('validatingAllProfiles', {
+                text: commands.project.validate.spinners.allProfilesValidationFailed,
+            });
+        }
+        errors.forEach(error => {
+            uiLogger.log('');
+            if (error instanceof Error) {
+                logError(error);
+            }
+            else {
+                uiLogger.error(error);
+            }
+        });
+    }
+    else if (profiles.length === 0) {
+        // If the project has no profiles, validate the project without a profile
+        try {
+            await handleTranslate(projectDir, projectConfig, derivedAccountId, false, undefined);
+        }
+        catch (e) {
+            uiLogger.error(commands.project.validate.failure(projectConfig.name));
+            logError(e);
+            validationSucceeded = false;
+            uiLogger.log('');
+        }
+    }
+    if (!validationSucceeded) {
         process.exit(EXIT_CODES.ERROR);
     }
     try {
-        await handleTranslate(projectDir, projectConfig, targetAccountId, false, profile);
+        await validateSourceDirectory(srcDir, projectConfig, projectDir);
     }
     catch (e) {
         logError(e);
-        uiLogger.error(commands.project.validate.failure(projectConfig.name));
         process.exit(EXIT_CODES.ERROR);
     }
     uiLogger.success(commands.project.validate.success(projectConfig.name));

package/lang/en.d.ts

@@ -1802,7 +1802,16 @@ export declare const commands: {
                 default: string;
             };
             success: (projectName: string) => string;
-            failure: (projectName: string) => string;
+            failure: (projectName: string, profileName?: string) => string;
+            spinners: {
+                validatingProfile: (profileName: string) => string;
+                profileValidationFailed: (profileName: string) => string;
+                profileValidationSucceeded: (profileName: string) => string;
+                invalidWithProfile: (profileName: string, projectName: string) => string;
+                validatingAllProfiles: string;
+                allProfilesValidationSucceeded: string;
+                allProfilesValidationFailed: string;
+            };
             options: {
                 profile: {
                     describe: string;
@@ -2844,11 +2853,6 @@ export declare const lib: {
             startError: (message: string) => string;
             fileChangeError: (message: string) => string;
         };
-        devSession: {
-            registrationError: (message: string) => string;
-            heartbeatError: (message: string) => string;
-            deletionError: (message: string) => string;
-        };
     };
     AppDevModeInterface: {
         autoInstallStaticAuthApp: {
@@ -2961,7 +2965,7 @@ export declare const lib: {
         updateNotification: {
             notifyTitle: string;
             cmsUpdateNotification: (packageName: string) => string;
-            cliUpdateNotification: string;
+            cliUpdateNotification: (currentVersion: string, updateCommand: string, latestVersion: string) => string;
         };
         autoUpdateCLI: {
             updateAvailable: (latestVersion: string) => string;
@@ -2986,7 +2990,9 @@ export declare const lib: {
                 noProjectConfig: string;
                 profileNotFound: (profileName: string) => string;
                 missingAccountId: (profileName: string) => string;
+                listedAccountNotFound: (accountId: number, profileName: string) => string;
                 failedToLoadProfile: (profileName: string) => string;
+                profileNotValid: (profileName: string, errors: string[]) => string;
             };
         };
     };
@@ -3077,9 +3083,6 @@ export declare const lib: {
             legacyFileDetected: (filename: string, platformVersion: string) => string;
         };
     };
-    boxen: {
-        failedToLoad: string;
-    };
     importData: {
         errors: {
             incorrectAccountType: (derivedAccountId: number) => string;