@hubspot/cli 7.10.0 → 7.10.1-experimental.0

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

@@ -8,6 +8,8 @@ import * as ui from '../../../lib/ui/index.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import { logError } from '../../../lib/errorHandlers/index.js';
 import projectLogsCommand from '../logs.js';
+import * as config from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 vi.mock('../../ui/logger.js');
 vi.mock('../../../lib/commonOpts');
 vi.mock('../../../lib/usageTracking');
@@ -25,6 +27,7 @@ const projectLogsManagerGetFunctionNamesSpy = vi.spyOn(ProjectLogsManager, 'getF
 const projectLogsManagerInitSpy = vi.spyOn(ProjectLogsManager, 'init');
 const getTableHeaderSpy = vi.spyOn(table, 'getTableHeader');
 const getTableContentsSpy = vi.spyOn(table, 'getTableContents');
+const getConfigAccountEnvironmentSpy = vi.spyOn(config, 'getConfigAccountEnvironment');
 const optionsSpy = vi
     .spyOn(yargs, 'options')
     .mockReturnValue(yargs);
@@ -34,6 +37,7 @@ const conflictsSpy = vi
 const exampleSpy = vi
     .spyOn(yargs, 'example')
     .mockReturnValue(yargs);
+getConfigAccountEnvironmentSpy.mockReturnValue(ENVIRONMENTS.PROD);
 describe('commands/project/logs', () => {
     beforeEach(() => {
         // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables

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 { getAccountConfig } from '@hubspot/local-dev-lib/config';
+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(getAccountConfig).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/cloneApp.js

@@ -14,7 +14,7 @@ import { cloneApp, checkCloneStatus, downloadClonedProject, } from '@hubspot/loc
 import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { uiLogger } from '../../lib/ui/logger.js';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import SpinniesManager from '../../lib/ui/SpinniesManager.js';
 import { logInvalidAccountError } from '../../lib/app/migrate.js';
 import { makeYargsBuilder } from '../../lib/yargsUtils.js';
@@ -25,7 +25,7 @@ const deprecated = true;
 async function handler(args) {
     const { derivedAccountId } = args;
     await trackCommandUsage('clone-app', {}, derivedAccountId);
-    const accountConfig = getAccountConfig(derivedAccountId);
+    const accountConfig = getConfigAccountById(derivedAccountId);
     const accountName = uiAccountDescription(derivedAccountId);
     if (!accountConfig) {
         throw new Error(commands.project.cloneApp.errors.noAccountConfig(derivedAccountId));

package/commands/project/deploy.js

@@ -1,5 +1,5 @@
 import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import { isV2Project } from '../../lib/projects/platformVersion.js';
 import { trackCommandUsage } from '../../lib/usageTracking.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';
@@ -19,7 +18,7 @@ const command = 'deploy';
 const describe = commands.project.deploy.describe;
 async function handler(args) {
     const { derivedAccountId, project: projectOption, buildId: buildIdOption, force: forceOption, deployLatestBuild: deployLatestBuildOption, json: formatOutputAsJson, } = args;
-    const accountConfig = getAccountConfig(derivedAccountId);
+    const accountConfig = getConfigAccountById(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     let targetAccountId;
     const jsonOutput = {};
@@ -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/deprecatedFlow.js

@@ -1,5 +1,4 @@
-import { getAccountConfig, getConfigAccounts, getEnv, } from '@hubspot/local-dev-lib/config';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getConfigAccountById, getAllConfigAccounts, getConfigAccountEnvironment, } from '@hubspot/local-dev-lib/config';
 import { findProjectComponents, getProjectComponentTypes, } from '../../../lib/projects/structure.js';
 import { ComponentTypes } from '../../../types/Projects.js';
 import { commands } from '../../../lang/en.js';
@@ -14,13 +13,13 @@ import { isSandbox, isDeveloperTestAccount, } from '../../../lib/accountTypes.js
 import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
 export async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
     const { userProvidedAccount, derivedAccountId } = args;
-    const env = getValidEnv(getEnv(derivedAccountId));
+    const env = getConfigAccountEnvironment(derivedAccountId);
     const components = await findProjectComponents(projectDir);
     const runnableComponents = components.filter(component => component.runnable);
     const componentTypes = getProjectComponentTypes(runnableComponents);
     const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
     const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
-    const accountConfig = getAccountConfig(accountId);
+    const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
         uiLogger.error(commands.project.dev.errors.noAccount(accountId));
         process.exit(EXIT_CODES.ERROR);
@@ -33,7 +32,7 @@ export async function deprecatedProjectDevFlow({ args, accountId, projectConfig,
         uiLogger.error(commands.project.dev.errors.invalidProjectComponents);
         process.exit(EXIT_CODES.SUCCESS);
     }
-    const accounts = getConfigAccounts();
+    const accounts = getAllConfigAccounts();
     if (!accounts) {
         uiLogger.error(commands.project.dev.errors.noAccountsInConfig);
         process.exit(EXIT_CODES.ERROR);

package/commands/project/dev/index.js

@@ -1,5 +1,5 @@
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
-import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import { uiLine } from '../../../lib/ui/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';
@@ -51,7 +51,8 @@ async function handler(args) {
     let profile;
     // Using the new --projectAccount flag
     if (projectAccount) {
-        targetProjectAccountId = getAccountId(projectAccount);
+        targetProjectAccountId =
+            getConfigAccountIfExists(projectAccount)?.accountId;
         if (targetProjectAccountId) {
             uiLogger.log('');
             uiLogger.log(commands.project.dev.logs.projectAccountFlagExplanation(targetProjectAccountId));
@@ -63,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);
             }
@@ -74,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) {
@@ -87,7 +97,9 @@ async function handler(args) {
     }
     trackCommandUsage('project-dev', {}, targetProjectAccountId);
     if (isV2Project(projectConfig.platformVersion)) {
-        const targetTestingAccountId = (testingAccount && getAccountId(testingAccount)) || undefined;
+        const targetTestingAccountId = testingAccount
+            ? getConfigAccountIfExists(testingAccount)?.accountId
+            : undefined;
         await unifiedProjectDevFlow({
             args,
             targetProjectAccountId,

package/commands/project/dev/unifiedFlow.js

@@ -4,8 +4,7 @@ import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { startPortManagerServer, stopPortManagerServer, } from '@hubspot/local-dev-lib/portManager';
 import { isTranslationError } from '@hubspot/project-parsing-lib/src/lib/errors.js';
 import { translateForLocalDev } from '@hubspot/project-parsing-lib';
-import { getEnv, getConfigAccounts, getAccountConfig, } from '@hubspot/local-dev-lib/config';
-import { getValidEnv } from '@hubspot/local-dev-lib/environment';
+import { getConfigAccountEnvironment, getAllConfigAccounts, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
 import { logError } from '../../../lib/errorHandlers/index.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
@@ -23,7 +22,7 @@ import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebs
 import { confirmLocalDevIsNotRunning } from '../../../lib/projects/localDev/helpers/process.js';
 export async function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }) {
     await confirmLocalDevIsNotRunning();
-    const env = getValidEnv(getEnv(targetProjectAccountId));
+    const env = getConfigAccountEnvironment(targetProjectAccountId);
     let projectNodes;
     let projectProfileData;
     // Get IR
@@ -50,12 +49,12 @@ export async function unifiedProjectDevFlow({ args, targetProjectAccountId, prov
         uiLogger.error(commands.project.dev.errors.noRunnableComponents);
         process.exit(EXIT_CODES.SUCCESS);
     }
-    const targetProjectAccountConfig = getAccountConfig(targetProjectAccountId);
+    const targetProjectAccountConfig = getConfigAccountById(targetProjectAccountId);
     if (!targetProjectAccountConfig) {
         uiLogger.error(commands.project.dev.errors.noAccount(targetProjectAccountId));
         process.exit(EXIT_CODES.ERROR);
     }
-    const accounts = getConfigAccounts();
+    const accounts = getAllConfigAccounts();
     const accountIsCombined = await isUnifiedAccount(targetProjectAccountConfig);
     const targetProjectAccountIsTestAccountOrSandbox = isTestAccountOrSandbox(targetProjectAccountConfig);
     if (!accountIsCombined) {

package/commands/project/lint.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectLintArgs = CommonArgs & {
+    installMissingDeps?: boolean;
+};
+declare const projectLintCommand: YargsCommandModule<unknown, ProjectLintArgs>;
+export default projectLintCommand;