@hubspot/cli 7.11.8-experimental.0 → 8.0.0-beta.1

package/commands/init.js

@@ -55,8 +55,14 @@ async function oauthConfigCreationFlow(env) {
             tokenInfo: {},
         },
     };
-    await authenticateWithOauth(oauthAccount);
-    setConfigAccountAsDefault(configData.accountId);
+    try {
+        await authenticateWithOauth(oauthAccount);
+        setConfigAccountAsDefault(configData.accountId);
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
     return oauthAccount;
 }
 const AUTH_TYPE_NAMES = {

package/commands/mcp/__tests__/start.test.js

@@ -1,7 +1,42 @@
+import { spawn } from 'node:child_process';
+import fs from 'fs';
+import { EventEmitter } from 'events';
+import * as configLib from '@hubspot/local-dev-lib/config';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import * as errorHandlers from '../../../lib/errorHandlers/index.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as processLib from '../../../lib/process.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
 import startCommand from '../start.js';
 vi.mock('yargs');
 vi.mock('../../../lib/commonOpts');
+vi.mock('node:child_process');
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../lib/errorHandlers/index.js');
+vi.mock('../../../lib/process.js');
+const spawnSpy = vi.mocked(spawn);
+const existsSyncSpy = vi.spyOn(fs, 'existsSync');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const handleExitSpy = vi.spyOn(processLib, 'handleExit');
+const logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+const processExitSpy = vi.spyOn(process, 'exit');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+class MockChildProcess extends EventEmitter {
+    kill = vi.fn();
+}
 describe('commands/mcp/start', () => {
+    let mockChildProcess;
+    beforeEach(() => {
+        mockChildProcess = new MockChildProcess();
+        // @ts-expect-error Mock implementation
+        spawnSpy.mockReturnValue(mockChildProcess);
+        existsSyncSpy.mockReturnValue(true);
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        // Mock config to prevent reading actual config file in CI
+        getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+    });
     describe('command', () => {
         it('should have the correct command structure', () => {
             expect(startCommand.command).toEqual('start');
@@ -19,9 +54,84 @@ describe('commands/mcp/start', () => {
         });
     });
     describe('handler', () => {
-        it('should be defined', () => {
-            expect(startCommand.handler).toBeDefined();
-            expect(typeof startCommand.handler).toBe('function');
+        let args;
+        beforeEach(() => {
+            args = {
+                aiAgent: 'test-agent',
+                derivedAccountId: 123456,
+                d: false,
+                debug: false,
+            };
+        });
+        it('should track command usage', async () => {
+            await startCommand.handler(args);
+            expect(trackCommandUsageSpy).toHaveBeenCalledWith('mcp-start', {}, 123456);
+        });
+        it('should check if server file exists', async () => {
+            await startCommand.handler(args);
+            expect(existsSyncSpy).toHaveBeenCalledWith(expect.stringContaining('server.js'));
+        });
+        it('should error if server file does not exist', async () => {
+            existsSyncSpy.mockReturnValue(false);
+            await startCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
+            expect(spawnSpy).not.toHaveBeenCalled();
+        });
+        it('should spawn server process with correct arguments', async () => {
+            await startCommand.handler(args);
+            expect(spawnSpy).toHaveBeenCalledWith('node', [expect.stringContaining('server.js')], expect.objectContaining({
+                stdio: 'inherit',
+                env: expect.objectContaining({
+                    HUBSPOT_MCP_AI_AGENT: 'test-agent',
+                }),
+            }));
+        });
+        it('should use "unknown" as default AI agent', async () => {
+            delete args.aiAgent;
+            await startCommand.handler(args);
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.objectContaining({
+                    HUBSPOT_MCP_AI_AGENT: 'unknown',
+                }),
+            }));
+        });
+        it('should log debug messages when starting', async () => {
+            await startCommand.handler(args);
+            expect(uiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Starting'));
+            expect(uiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('stop'));
+        });
+        it('should handle child process errors', async () => {
+            await startCommand.handler(args);
+            const error = new Error('Process error');
+            mockChildProcess.emit('error', error);
+            expect(logErrorSpy).toHaveBeenCalledWith(error);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
+        });
+        it('should handle child process close', async () => {
+            await startCommand.handler(args);
+            mockChildProcess.emit('close');
+            expect(uiLogger.info).toHaveBeenCalledWith(expect.stringMatching(/stopped/i));
+        });
+        it('should register exit handler', async () => {
+            await startCommand.handler(args);
+            expect(handleExitSpy).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('should kill child process on exit', async () => {
+            await startCommand.handler(args);
+            const exitHandler = handleExitSpy.mock.calls[0][0];
+            exitHandler({ isSIGHUP: false });
+            expect(uiLogger.info).toHaveBeenCalledWith(expect.stringContaining('Shutting'));
+            expect(mockChildProcess.kill).toHaveBeenCalledWith('SIGTERM');
+            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+        });
+        it('should handle exceptions during server start', async () => {
+            const error = new Error('Spawn failed');
+            spawnSpy.mockImplementation(() => {
+                throw error;
+            });
+            await startCommand.handler(args);
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
+            expect(logErrorSpy).toHaveBeenCalledWith(error);
         });
     });
 });

package/commands/mcp/setup.js

@@ -16,13 +16,6 @@ async function handler(args) {
         uiLogger.error(commands.mcp.setup.errors.needsMcpAccess(derivedAccountId));
         process.exit(EXIT_CODES.ERROR);
     }
-    try {
-        await import('@modelcontextprotocol/sdk/server/mcp.js');
-    }
-    catch (e) {
-        uiLogger.error(commands.mcp.setup.errors.needsNode20);
-        process.exit(EXIT_CODES.ERROR);
-    }
     trackCommandUsage('mcp-setup', {}, args.derivedAccountId);
     try {
         await addMcpServerToConfig(args.client);

package/commands/mcp/start.d.ts

@@ -1,6 +1,6 @@
 import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
 interface McpStartArgs extends CommonArgs {
-    aiAgent: string;
+    aiAgent?: string;
 }
 declare const mcpStartCommand: YargsCommandModule<unknown, McpStartArgs>;
 export default mcpStartCommand;

package/commands/mcp/start.js

@@ -14,13 +14,6 @@ const describe = undefined; // Leave hidden for now
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 async function handler(args) {
-    try {
-        await import('@modelcontextprotocol/sdk/server/mcp.js');
-    }
-    catch (e) {
-        uiLogger.error(commands.mcp.start.errors.needsNode20);
-        process.exit(EXIT_CODES.ERROR);
-    }
     trackCommandUsage('mcp-start', {}, args.derivedAccountId);
     await startMcpServer(args.aiAgent);
 }

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

@@ -7,13 +7,11 @@ import { getProjectConfig } from '../../../lib/projects/config.js';
 import { isV2Project } from '../../../lib/projects/platformVersion.js';
 import { trackCommandUsage } from '../../../lib/usageTracking.js';
 vi.mock('../../../lib/commonOpts');
-vi.mock('../../../lib/ui/logger.js');
 vi.mock('../../../lib/errorHandlers/index.js');
 vi.mock('../../../lib/projects/add/v2AddComponent');
 vi.mock('../../../lib/projects/add/legacyAddComponent');
 vi.mock('../../../lib/projects/config');
 vi.mock('../../../lib/projects/platformVersion');
-vi.mock('../../../lib/usageTracking');
 const mockedV2AddComponent = vi.mocked(v2AddComponent);
 const mockedLegacyAddComponent = vi.mocked(legacyAddComponent);
 const mockedGetProjectConfig = vi.mocked(getProjectConfig);

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

@@ -50,7 +50,7 @@ describe('commands/project/create', () => {
             expect(optionsCall['platform-version']).toEqual(expect.objectContaining({
                 describe: 'The target platform version for the new project.',
                 type: 'string',
-                choices: ['2023.2', '2025.1', '2025.2'],
+                choices: ['2025.1', '2025.2'],
                 default: '2025.2',
             }));
         });
@@ -79,7 +79,7 @@ describe('commands/project/create', () => {
             projectCreateCommand.builder(yargsMock);
             const optionsCall = optionsSpy.mock.calls[0][0];
             expect(optionsCall.auth).toEqual(expect.objectContaining({
-                describe: 'Authentication model for the application.',
+                describe: 'Authentication model for the app.',
                 type: 'string',
                 choices: ['oauth', 'static'],
             }));

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

@@ -27,9 +27,6 @@ vi.mock('../../../lib/projects/pollProjectBuildAndDeploy');
 vi.mock('../../../lib/projects/platformVersion');
 vi.mock('../../../lib/prompts/projectNamePrompt');
 vi.mock('../../../lib/prompts/promptUtils');
-vi.mock('../../../lib/usageTracking');
-vi.mock('../../../lib/ui/logger');
-vi.mock('../../ui/logger.js');
 vi.spyOn(ui, 'uiLine');
 const uiCommandReferenceSpy = vi.spyOn(ui, 'uiCommandReference');
 const uiAccountDescriptionSpy = vi.spyOn(ui, 'uiAccountDescription');
@@ -87,7 +84,6 @@ describe('commands/project/deploy', () => {
                 [profileFlag]: expect.objectContaining({
                     type: 'string',
                     alias: ['p'],
-                    hidden: true,
                 }),
                 [forceFlag]: expect.objectContaining({
                     type: 'boolean',

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

@@ -0,0 +1,273 @@
+import * as configLib from '@hubspot/local-dev-lib/config';
+import * as projectConfigLib from '../../../lib/projects/config.js';
+import * as platformVersionLib from '../../../lib/projects/platformVersion.js';
+import * as projectProfilesLib from '../../../lib/projects/projectProfiles.js';
+import * as projectParsingProfiles from '@hubspot/project-parsing-lib/profiles';
+import * as promptUtilsLib from '../../../lib/prompts/promptUtils.js';
+import * as usageTrackingLib from '../../../lib/usageTracking.js';
+import * as errorHandlers from '../../../lib/errorHandlers/index.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import * as deprecatedFlowLib from '../dev/deprecatedFlow.js';
+import * as unifiedFlowLib from '../dev/unifiedFlow.js';
+import projectDevCommand from '../dev/index.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/project-parsing-lib/profiles');
+vi.mock('../../../lib/projects/config.js');
+vi.mock('../../../lib/projects/platformVersion.js');
+vi.mock('../../../lib/projects/projectProfiles.js');
+vi.mock('../../../lib/prompts/promptUtils.js');
+vi.mock('../../../lib/errorHandlers/index.js');
+vi.mock('../../../lib/ui/index.js');
+vi.mock('../dev/deprecatedFlow.js');
+vi.mock('../dev/unifiedFlow.js');
+const getConfigAccountIfExistsSpy = vi.spyOn(configLib, 'getConfigAccountIfExists');
+const getProjectConfigSpy = vi.spyOn(projectConfigLib, 'getProjectConfig');
+const validateProjectConfigSpy = vi.spyOn(projectConfigLib, 'validateProjectConfig');
+const isV2ProjectSpy = vi.spyOn(platformVersionLib, 'isV2Project');
+const loadProfileSpy = vi.spyOn(projectProfilesLib, 'loadProfile');
+const enforceProfileUsageSpy = vi.spyOn(projectProfilesLib, 'enforceProfileUsage');
+const getAllHsProfilesSpy = vi.spyOn(projectParsingProfiles, 'getAllHsProfiles');
+const listPromptSpy = vi.spyOn(promptUtilsLib, 'listPrompt');
+const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
+const logErrorSpy = vi.spyOn(errorHandlers, 'logError');
+const deprecatedProjectDevFlowSpy = vi.spyOn(deprecatedFlowLib, 'deprecatedProjectDevFlow');
+const unifiedProjectDevFlowSpy = vi.spyOn(unifiedFlowLib, 'unifiedProjectDevFlow');
+const processExitSpy = vi.spyOn(process, 'exit');
+describe('commands/project/dev', () => {
+    beforeEach(() => {
+        // @ts-expect-error Mock implementation
+        processExitSpy.mockImplementation(() => { });
+        getProjectConfigSpy.mockResolvedValue({
+            projectConfig: {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: 'v2',
+            },
+            projectDir: '/test/project',
+        });
+        validateProjectConfigSpy.mockImplementation(() => { });
+        isV2ProjectSpy.mockReturnValue(true);
+        trackCommandUsageSpy.mockImplementation(async () => { });
+        deprecatedProjectDevFlowSpy.mockResolvedValue(undefined);
+        unifiedProjectDevFlowSpy.mockResolvedValue(undefined);
+        enforceProfileUsageSpy.mockResolvedValue(undefined);
+        getAllHsProfilesSpy.mockResolvedValue([]);
+        listPromptSpy.mockResolvedValue('dev');
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(projectDevCommand.command).toEqual('dev');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(projectDevCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should be a function', () => {
+            expect(typeof projectDevCommand.builder).toBe('function');
+        });
+    });
+    describe('handler', () => {
+        let args;
+        beforeEach(() => {
+            args = {
+                derivedAccountId: 123456,
+            };
+        });
+        describe('validation', () => {
+            it('should validate project config', async () => {
+                await projectDevCommand.handler(args);
+                expect(validateProjectConfigSpy).toHaveBeenCalledWith({
+                    name: 'test-project',
+                    srcDir: 'src',
+                    platformVersion: 'v2',
+                }, '/test/project');
+            });
+            it('should exit if project config validation fails', async () => {
+                const error = new Error('Invalid config');
+                validateProjectConfigSpy.mockImplementation(() => {
+                    throw error;
+                });
+                await projectDevCommand.handler(args);
+                expect(logErrorSpy).toHaveBeenCalledWith(error);
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should exit if no project directory', async () => {
+                getProjectConfigSpy.mockResolvedValue({
+                    projectConfig: {
+                        name: 'test-project',
+                        srcDir: 'src',
+                        platformVersion: 'v2',
+                    },
+                    projectDir: null,
+                });
+                // Make process.exit actually throw to stop execution
+                processExitSpy.mockImplementation((code) => {
+                    throw new Error(`process.exit called with ${code}`);
+                });
+                await expect(projectDevCommand.handler(args)).rejects.toThrow('process.exit called');
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('project'));
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should error if using testingAccount and projectAccount with legacy project', async () => {
+                isV2ProjectSpy.mockReturnValue(false);
+                args.testingAccount = '111111';
+                args.projectAccount = '222222';
+                await projectDevCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('--project-account and --testing-account'));
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should error if using account flag with V2 project', async () => {
+                isV2ProjectSpy.mockReturnValue(true);
+                args.userProvidedAccount = '123456';
+                await projectDevCommand.handler(args);
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('--account flag'));
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+        });
+        describe('account resolution', () => {
+            it('should use projectAccount flag', async () => {
+                args.projectAccount = '999999';
+                getConfigAccountIfExistsSpy.mockReturnValue({
+                    accountId: 999999,
+                });
+                await projectDevCommand.handler(args);
+                expect(getConfigAccountIfExistsSpy).toHaveBeenCalledWith('999999');
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 999999);
+            });
+            it('should use userProvidedAccount for legacy projects', async () => {
+                isV2ProjectSpy.mockReturnValue(false);
+                args.userProvidedAccount = '888888';
+                args.derivedAccountId = 888888;
+                await projectDevCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 888888);
+            });
+            it('should use profile accountId when profile specified', async () => {
+                args.profile = 'test-profile';
+                loadProfileSpy.mockReturnValue({
+                    accountId: 777777,
+                });
+                await projectDevCommand.handler(args);
+                expect(loadProfileSpy).toHaveBeenCalledWith({
+                    name: 'test-project',
+                    srcDir: 'src',
+                    platformVersion: 'v2',
+                }, '/test/project', 'test-profile');
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 777777);
+            });
+            it('should exit if profile loading fails', async () => {
+                args.profile = 'invalid-profile';
+                const error = new Error('Profile not found');
+                loadProfileSpy.mockImplementation(() => {
+                    throw error;
+                });
+                // Make process.exit actually throw to stop execution
+                processExitSpy.mockImplementation((code) => {
+                    throw new Error(`process.exit called with ${code}`);
+                });
+                await expect(projectDevCommand.handler(args)).rejects.toThrow('process.exit called');
+                expect(logErrorSpy).toHaveBeenCalledWith(error);
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should prompt for profile selection when profiles exist and no profile is specified', async () => {
+                getAllHsProfilesSpy.mockResolvedValue(['dev', 'prod']);
+                listPromptSpy.mockResolvedValue('dev');
+                loadProfileSpy.mockReturnValue({
+                    accountId: 789012,
+                    variables: {},
+                });
+                await projectDevCommand.handler(args);
+                expect(getAllHsProfilesSpy).toHaveBeenCalledWith('/test/project/src');
+                expect(listPromptSpy).toHaveBeenCalledWith(expect.any(String), {
+                    choices: ['dev', 'prod'],
+                });
+                expect(loadProfileSpy).toHaveBeenCalledWith({
+                    name: 'test-project',
+                    srcDir: 'src',
+                    platformVersion: 'v2',
+                }, '/test/project', 'dev');
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 789012);
+            });
+            it('should exit if profile loading fails after selection', async () => {
+                getAllHsProfilesSpy.mockResolvedValue(['dev', 'prod']);
+                listPromptSpy.mockResolvedValue('dev');
+                const error = new Error('Failed to load profile');
+                loadProfileSpy.mockImplementation(() => {
+                    throw error;
+                });
+                // Make process.exit actually throw to stop execution
+                processExitSpy.mockImplementation((code) => {
+                    throw new Error(`process.exit called with ${code}`);
+                });
+                await expect(projectDevCommand.handler(args)).rejects.toThrow('process.exit called');
+                expect(logErrorSpy).toHaveBeenCalledWith(error);
+                expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            });
+            it('should use derivedAccountId as fallback', async () => {
+                await projectDevCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 123456);
+            });
+        });
+        describe('dev flow execution', () => {
+            it('should track command usage', async () => {
+                await projectDevCommand.handler(args);
+                expect(trackCommandUsageSpy).toHaveBeenCalledWith('project-dev', {}, 123456);
+            });
+            it('should run unified flow for V2 projects', async () => {
+                isV2ProjectSpy.mockReturnValue(true);
+                await projectDevCommand.handler(args);
+                expect(unifiedProjectDevFlowSpy).toHaveBeenCalledWith({
+                    args,
+                    targetProjectAccountId: 123456,
+                    providedTargetTestingAccountId: undefined,
+                    projectConfig: {
+                        name: 'test-project',
+                        srcDir: 'src',
+                        platformVersion: 'v2',
+                    },
+                    projectDir: '/test/project',
+                    profileConfig: undefined,
+                });
+                expect(deprecatedProjectDevFlowSpy).not.toHaveBeenCalled();
+            });
+            it('should run deprecated flow for legacy projects', async () => {
+                isV2ProjectSpy.mockReturnValue(false);
+                await projectDevCommand.handler(args);
+                expect(deprecatedProjectDevFlowSpy).toHaveBeenCalledWith({
+                    args,
+                    accountId: 123456,
+                    projectConfig: {
+                        name: 'test-project',
+                        srcDir: 'src',
+                        platformVersion: 'v2',
+                    },
+                    projectDir: '/test/project',
+                });
+                expect(unifiedProjectDevFlowSpy).not.toHaveBeenCalled();
+            });
+            it('should pass testingAccount to unified flow', async () => {
+                isV2ProjectSpy.mockReturnValue(true);
+                args.testingAccount = '555555';
+                getConfigAccountIfExistsSpy.mockReturnValue({
+                    accountId: 555555,
+                });
+                await projectDevCommand.handler(args);
+                expect(unifiedProjectDevFlowSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    providedTargetTestingAccountId: 555555,
+                }));
+            });
+            it('should pass profile config to unified flow', async () => {
+                args.profile = 'dev-profile';
+                const profileConfig = { accountId: 666666 };
+                loadProfileSpy.mockReturnValue(profileConfig);
+                await projectDevCommand.handler(args);
+                expect(unifiedProjectDevFlowSpy).toHaveBeenCalledWith(expect.objectContaining({
+                    profileConfig,
+                }));
+            });
+        });
+    });
+});

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

@@ -1,6 +1,6 @@
 import path from 'path';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib/translate';
 import { getAllConfigAccounts, getConfigAccountById, getConfigAccountEnvironment, } from '@hubspot/local-dev-lib/config';
 import { getValidEnv } from '@hubspot/local-dev-lib/environment';
 import { getServerPortByInstanceId } from '@hubspot/local-dev-lib/portManager';
@@ -31,7 +31,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => ({
     },
 }));
 // Mock all dependencies
-vi.mock('@hubspot/project-parsing-lib');
+vi.mock('@hubspot/project-parsing-lib/translate');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/environment');
 vi.mock('@hubspot/local-dev-lib/portManager');
@@ -47,7 +47,6 @@ vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
 vi.mock('../../../lib/process');
 vi.mock('../../../lib/accountTypes');
 vi.mock('../../../lib/ui');
-vi.mock('../../../lib/ui/logger');
 describe('unifiedProjectDevFlow', () => {
     const mockArgs = {
         profile: 'test-profile',
@@ -110,7 +109,6 @@ describe('unifiedProjectDevFlow', () => {
         shutdown: vi.fn().mockResolvedValue(undefined),
     };
     beforeEach(() => {
-        vi.clearAllMocks();
         // Mock process.exit
         vi.spyOn(global.process, 'exit').mockImplementation((code) => {
             throw new Error(`Process.exit called with code ${code}`);
@@ -376,7 +374,6 @@ describe('unifiedProjectDevFlow', () => {
             expect(mockLocalDevProcess.start).toHaveBeenCalled();
             expect(mockLocalDevWatcher.start).toHaveBeenCalled();
             expect(mockWebsocketServer.start).toHaveBeenCalled();
-            expect(SpinniesManager.init).toHaveBeenCalled();
         });
     });
     describe('UI messaging', () => {

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

@@ -7,11 +7,9 @@ import { trackCommandUsage } from '../../../lib/usageTracking.js';
 import * as dependencyManagement from '../../../lib/dependencyManagement.js';
 import * as promptUtils from '../../../lib/prompts/promptUtils.js';
 import projectInstallDepsCommand from '../installDeps.js';
-vi.mock('../../../lib/ui/logger.js');
 vi.mock('../../../lib/projects/config');
 vi.mock('../../../lib/dependencyManagement');
 vi.mock('../../../lib/prompts/promptUtils');
-vi.mock('../../../lib/usageTracking');
 vi.mock('../../../lib/commonOpts');
 const exampleSpy = vi.spyOn(yargs, 'example');
 const processExitSpy = vi.spyOn(process, 'exit');

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

@@ -9,13 +9,11 @@ import * as promptUtils from '../../../lib/prompts/promptUtils.js';
 import * as linting from '../../../lib/projects/uieLinting.js';
 import { REQUIRED_PACKAGES_AND_MIN_VERSIONS } from '../../../lib/projects/uieLinting.js';
 import projectLintCommand from '../lint.js';
-vi.mock('../../../lib/ui/logger.js');
 vi.mock('../../../lib/ui/SpinniesManager.js');
 vi.mock('../../../lib/projects/config');
 vi.mock('../../../lib/dependencyManagement');
 vi.mock('../../../lib/prompts/promptUtils');
 vi.mock('../../../lib/projects/uieLinting');
-vi.mock('../../../lib/usageTracking');
 vi.mock('../../../lib/commonOpts');
 const exampleSpy = vi.spyOn(yargs, 'example');
 const processExitSpy = vi.spyOn(process, 'exit');
@@ -63,9 +61,6 @@ describe('commands/project/lint', () => {
             lintPackagesSpy.mockResolvedValue({ success: true, results: [] });
             displayLintResultsSpy.mockImplementation(() => { });
         });
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
         it('should track the command usage', async () => {
             getProjectConfigSpy.mockResolvedValue({
                 projectDir: '/test/project',