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

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

@@ -37,7 +37,7 @@ const getProjectConfigSpy = vi.spyOn(projectUtils, 'getProjectConfig');
 const projectNamePromptSpy = vi.spyOn(projectNamePrompt, 'projectNamePrompt');
 const getProjectDetailUrlSpy = vi.spyOn(projectUrlUtils, 'getProjectDetailUrl');
 const fetchProjectSpy = vi.spyOn(projectApiUtils, 'fetchProject');
-const deployProjectSpy = vi.spyOn(projectApiUtils, 'deployProject');
+const deployProjectV1Spy = vi.spyOn(projectApiUtils, 'deployProjectV1');
 const getConfigAccountByIdSpy = vi.spyOn(configUtils, 'getConfigAccountById');
 const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
 const processExitSpy = vi.spyOn(process, 'exit');
@@ -144,7 +144,7 @@ describe('commands/project/deploy', () => {
                 env: 'qa',
             });
             fetchProjectSpy.mockReturnValue(mockHubSpotHttpResponse(exampleProject));
-            deployProjectSpy.mockReturnValue(mockHubSpotHttpResponse(deployDetails));
+            deployProjectV1Spy.mockReturnValue(mockHubSpotHttpResponse(deployDetails));
             // Spy on process.exit so our tests don't close when it's called
             // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
             processExitSpy.mockImplementation(() => { });
@@ -245,12 +245,12 @@ describe('commands/project/deploy', () => {
         });
         it('should deploy the project', async () => {
             await projectDeployCommand.handler(args);
-            expect(deployProjectSpy).toHaveBeenCalledTimes(1);
-            expect(deployProjectSpy).toHaveBeenCalledWith(args.derivedAccountId, projectNameFromPrompt, args.buildId, undefined, undefined);
+            expect(deployProjectV1Spy).toHaveBeenCalledTimes(1);
+            expect(deployProjectV1Spy).toHaveBeenCalledWith(args.derivedAccountId, projectNameFromPrompt, args.buildId, undefined);
         });
         it('should log an error and exit when the deploy fails', async () => {
             // @ts-expect-error Testing an edge case where the response is empty
-            deployProjectSpy.mockResolvedValue({});
+            deployProjectV1Spy.mockResolvedValue({});
             await projectDeployCommand.handler(args);
             expect(uiLogger.error).toHaveBeenCalledTimes(1);
             expect(uiLogger.error).toHaveBeenCalledWith(`Deploy error: an unknown error occurred.`);

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

@@ -5,14 +5,11 @@ 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 { validateProjectForProfile } from '../../../lib/projectProfiles.js';
+import { loadAndValidateProfile } 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');
@@ -22,35 +19,15 @@ 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();
@@ -88,269 +65,34 @@ 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);
-        });
     });
-    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);
-            });
+    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('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(isV2Project).mockReturnValue(true);
+        vi.mocked(validateProjectConfig).mockReturnValue(undefined);
+        vi.mocked(loadAndValidateProfile).mockResolvedValue(123);
+        vi.mocked(getConfigAccountById).mockReturnValue({
+            accountType: 'STANDARD',
+            accountId: 123,
+            env: 'prod',
         });
+        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/create.js

@@ -7,7 +7,6 @@ import { writeProjectConfig, getProjectConfig, } from '../../lib/projects/config
 import { EMPTY_PROJECT_TEMPLATE_NAME } from '../../lib/projects/create/legacy.js';
 import { generateComponentPaths } from '../../lib/projects/create/v2.js';
 import { PROJECT_WITH_APP, EMPTY_PROJECT } from '../../lib/constants.js';
-import { uiFeatureHighlight } from '../../lib/ui/index.js';
 import { debugError, logError } from '../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
 import { PROJECT_CONFIG_FILE, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, marketplaceDistribution, privateDistribution, oAuth, staticAuth, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../lib/constants.js';
@@ -18,6 +17,7 @@ import { uiLogger } from '../../lib/ui/logger.js';
 import { handleProjectCreationFlow, } from '../../lib/projects/create/index.js';
 import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { updateHsMetaFilesWithAutoGeneratedFields } from '../../lib/projects/components.js';
+import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 const command = ['create', 'init'];
 const describe = commands.project.create.describe;
 const { v2023_2, v2025_1, v2025_2 } = PLATFORM_VERSIONS;
@@ -61,6 +61,12 @@ async function handler(args) {
         authType,
         distribution,
     });
+    const isProjectEmpty = selectProjectTemplatePromptResponse.projectTemplate?.name ===
+        EMPTY_PROJECT_TEMPLATE_NAME || projectContents === EMPTY_PROJECT;
+    SpinniesManager.init();
+    SpinniesManager.add('project-create', {
+        text: commands.project.create.creatingComponent(isProjectEmpty, projectNameAndDestPromptResponse.name),
+    });
     try {
         await cloneGithubRepo(repo, projectDest, {
             sourceDir: selectProjectTemplatePromptResponse.projectTemplate?.path || components,
@@ -69,6 +75,9 @@ async function handler(args) {
         });
     }
     catch (err) {
+        SpinniesManager.fail('project-create', {
+            text: commands.project.create.failure(isProjectEmpty, projectNameAndDestPromptResponse.name),
+        });
         debugError(err);
         uiLogger.error(commands.project.create.errors.failedToDownloadProject);
         process.exit(EXIT_CODES.ERROR);
@@ -80,23 +89,20 @@ async function handler(args) {
         ...parsedConfigFile,
         name: projectName,
     });
+    SpinniesManager.succeed('project-create', {
+        text: commands.project.create.success(isProjectEmpty, projectName),
+    });
     const projectMetadata = await getProjectMetadata(path.join(projectDest, parsedConfigFile.srcDir));
-    updateHsMetaFilesWithAutoGeneratedFields(projectName, projectMetadata.hsMetaFiles);
+    await updateHsMetaFilesWithAutoGeneratedFields(projectName, projectMetadata.hsMetaFiles, [], {
+        updatedProjectMetadata: projectMetadata,
+        showSuccessMessage: true,
+        isProjectEmpty,
+        projectDest,
+    });
     // If the template is 'no-template', we need to manually create a src directory
-    if (selectProjectTemplatePromptResponse.projectTemplate?.name ===
-        EMPTY_PROJECT_TEMPLATE_NAME ||
-        projectContents === EMPTY_PROJECT) {
+    if (isProjectEmpty) {
         fs.ensureDirSync(path.join(projectDest, 'src'));
     }
-    uiLogger.success(commands.project.create.logs.success(projectNameAndDestPromptResponse.name, projectDest));
-    uiLogger.log(commands.project.create.logs.welcomeMessage);
-    uiFeatureHighlight([
-        'projectCommandTip',
-        'projectUploadCommand',
-        'projectDevCommand',
-        'projectHelpCommand',
-        'feedbackCommand',
-    ]);
     process.exit(EXIT_CODES.SUCCESS);
 }
 function projectCreateBuilder(yargs) {

package/commands/project/deploy.js

@@ -7,10 +7,11 @@ 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, enforceProfileUsage, } from '../../lib/projectProfiles.js';
+import { loadProfile, logProfileFooter, logProfileHeader, exitIfUsingProfiles, } 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';
@@ -26,12 +27,9 @@ async function handler(args) {
     if (isV2Project(projectConfig?.platformVersion)) {
         if (args.profile) {
             logProfileHeader(args.profile);
-            let profile;
-            try {
-                profile = loadProfile(projectConfig, projectDir, args.profile);
-            }
-            catch (error) {
-                logError(error);
+            const profile = loadProfile(projectConfig, projectDir, args.profile);
+            if (!profile) {
+                uiLine();
                 process.exit(EXIT_CODES.ERROR);
             }
             targetAccountId = profile.accountId;
@@ -39,13 +37,7 @@ async function handler(args) {
         }
         else {
             // A profile must be specified if this project has profiles configured
-            try {
-                await enforceProfileUsage(projectConfig, projectDir);
-            }
-            catch (error) {
-                logError(error);
-                process.exit(EXIT_CODES.ERROR);
-            }
+            await exitIfUsingProfiles(projectConfig, projectDir);
         }
     }
     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, enforceProfileUsage, } from '../../../lib/projectProfiles.js';
+import { loadProfile, exitIfUsingProfiles, } 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,11 +64,8 @@ async function handler(args) {
     }
     if (!targetProjectAccountId && isV2Project(projectConfig.platformVersion)) {
         if (args.profile) {
-            try {
-                profile = loadProfile(projectConfig, projectDir, args.profile);
-            }
-            catch (error) {
-                logError(error);
+            profile = loadProfile(projectConfig, projectDir, args.profile);
+            if (!profile) {
                 uiLine();
                 process.exit(EXIT_CODES.ERROR);
             }
@@ -78,13 +75,7 @@ async function handler(args) {
         }
         else {
             // A profile must be specified if this project has profiles configured
-            try {
-                await enforceProfileUsage(projectConfig, projectDir);
-            }
-            catch (error) {
-                logError(error);
-                process.exit(EXIT_CODES.ERROR);
-            }
+            await exitIfUsingProfiles(projectConfig, projectDir);
         }
     }
     if (!targetProjectAccountId) {

package/commands/project/dev/unifiedFlow.js

@@ -123,7 +123,13 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
     // Check for missing/outdated dependencies
     await checkAndInstallDependencies();
     // End setup, start local dev process
-    await startPortManagerServer();
+    try {
+        await startPortManagerServer();
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
     const localDevProcess = new LocalDevProcess({
         initialProjectNodes: projectNodes,
         initialProjectProfileData: projectProfileData,

package/commands/project/upload.js

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