@hubspot/cli 8.0.10-experimental.7 → 8.0.11-experimental.0

package/lib/mcp/__tests__/setup.test.js

@@ -0,0 +1,523 @@
+import { execAsync } from '../../../mcp-server/utils/command.js';
+import { setupCodex, setupGemini, setupClaudeCode, setupCursor, setupWindsurf, setupVsCode, addMcpServerToConfig, supportedTools, } from '../setup.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import { logError } from '../../errorHandlers/index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { promptUser } from '../../prompts/promptUtils.js';
+import { commands } from '../../../lang/en.js';
+import fs from 'fs-extra';
+import { existsSync } from 'fs';
+import os from 'os';
+import path from 'path';
+// Mock dependencies
+vi.mock('../../../mcp-server/utils/command.js');
+vi.mock('../../ui/SpinniesManager.js');
+vi.mock('../../errorHandlers/index.js');
+vi.mock('../../ui/logger.js');
+vi.mock('../../prompts/promptUtils.js');
+vi.mock('fs-extra');
+vi.mock('fs');
+vi.mock('os');
+vi.mock('path');
+const mockedExecAsync = vi.mocked(execAsync);
+const mockedSpinniesManager = vi.mocked(SpinniesManager);
+const mockedLogError = vi.mocked(logError);
+describe('lib/mcp/setup', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('supportedTools', () => {
+        it('should include Codex in the supported tools list', () => {
+            const codexTool = supportedTools.find(tool => tool.value === 'codex');
+            expect(codexTool).toBeDefined();
+            expect(codexTool?.name).toBe(commands.mcp.setup.codex);
+            expect(codexTool?.value).toBe('codex');
+        });
+        it('should have Codex as the first tool in the list', () => {
+            expect(supportedTools[0].value).toBe('codex');
+        });
+        it('should contain all expected tools', () => {
+            const toolValues = supportedTools.map(tool => tool.value);
+            expect(toolValues).toContain('codex');
+            expect(toolValues).toContain('claude');
+            expect(toolValues).toContain('cursor');
+            expect(toolValues).toContain('gemini');
+            expect(toolValues).toContain('vscode');
+            expect(toolValues).toContain('windsurf');
+        });
+        it('should include Gemini in the supported tools list', () => {
+            const geminiTool = supportedTools.find(tool => tool.value === 'gemini');
+            expect(geminiTool).toBeDefined();
+            expect(geminiTool?.name).toBe(commands.mcp.setup.gemini);
+            expect(geminiTool?.value).toBe('gemini');
+        });
+    });
+    describe('setupCodex', () => {
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1', '--arg2'],
+        };
+        it('should successfully configure Codex when command is available', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.configuringCodex,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex --version');
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --arg2 --ai-agent codex');
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.configuredCodex,
+            });
+        });
+        it('should use default mcp command when none provided', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' }); // mcp add command
+            const result = await setupCodex();
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- hs mcp start --ai-agent codex');
+        });
+        it('should handle codex command not found', async () => {
+            const error = new Error('Command not found: codex');
+            mockedExecAsync.mockRejectedValueOnce(error);
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexNotFound,
+            });
+        });
+        it('should handle codex installation failure', async () => {
+            const error = new Error('Some other error');
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            }); // version check passes
+            mockedExecAsync.mockRejectedValueOnce(error); // mcp add fails
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+        it('should handle unexpected errors during spinner setup', async () => {
+            const error = new Error('Unexpected error');
+            mockedSpinniesManager.add.mockImplementationOnce(() => {
+                throw error;
+            });
+            const result = await setupCodex(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+        it('should pass through environment variables in command', async () => {
+            const mockMcpCommandWithEnv = {
+                command: 'test-command',
+                args: ['--arg1'],
+                env: { HUBSPOT_MCP_STANDALONE: 'true' },
+            };
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'codex version 1.0.0',
+                stderr: '',
+            });
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupCodex(mockMcpCommandWithEnv);
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" --env HUBSPOT_MCP_STANDALONE="true" -- test-command --arg1 --ai-agent codex');
+        });
+    });
+    describe('setupGemini', () => {
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1', '--arg2'],
+        };
+        it('should successfully configure Gemini CLI when command is available', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'gemini version 1.0.0',
+                stderr: '',
+            });
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupGemini(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('geminiSpinner', {
+                text: commands.mcp.setup.spinners.configuringGemini,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith('gemini --version');
+            expect(mockedExecAsync).toHaveBeenCalledWith('gemini mcp add -s user "HubSpotDev" test-command --arg1 --arg2 --ai-agent gemini');
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('geminiSpinner', {
+                text: commands.mcp.setup.spinners.configuredGemini,
+            });
+        });
+        it('should use default mcp command when none provided', async () => {
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'gemini version 1.0.0',
+                stderr: '',
+            });
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupGemini();
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith('gemini mcp add -s user "HubSpotDev" hs mcp start --ai-agent gemini');
+        });
+        it('should handle gemini command not found', async () => {
+            const error = new Error('Command not found: gemini');
+            mockedExecAsync.mockRejectedValueOnce(error);
+            const result = await setupGemini(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('geminiSpinner', {
+                text: commands.mcp.setup.spinners.geminiNotFound,
+            });
+        });
+        it('should handle gemini installation failure', async () => {
+            const error = new Error('Some other error');
+            mockedExecAsync.mockResolvedValueOnce({
+                stdout: 'gemini version 1.0.0',
+                stderr: '',
+            });
+            mockedExecAsync.mockRejectedValueOnce(error);
+            const result = await setupGemini(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('geminiSpinner', {
+                text: commands.mcp.setup.spinners.geminiInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+    });
+    describe('setupClaudeCode', () => {
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1', '--arg2'],
+        };
+        it('should successfully configure Claude Code when command is available', async () => {
+            mockedExecAsync
+                .mockResolvedValueOnce({ stdout: 'claude version 1.0.0', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupClaudeCode(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('claudeCode', {
+                text: commands.mcp.setup.spinners.configuringClaudeCode,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith('claude --version');
+            expect(mockedExecAsync).toHaveBeenCalledWith('claude mcp list');
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('claudeCode', {
+                text: commands.mcp.setup.spinners.configuredClaudeCode,
+            });
+        });
+        it('should remove and re-add when server is already installed', async () => {
+            mockedExecAsync
+                .mockResolvedValueOnce({ stdout: 'claude version 1.0.0', stderr: '' })
+                .mockResolvedValueOnce({ stdout: 'HubSpotDev some-config', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupClaudeCode(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.update).toHaveBeenCalledWith('claudeCode', {
+                text: commands.mcp.setup.spinners.alreadyInstalled,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith('claude mcp remove "HubSpotDev" --scope user');
+        });
+        it('should use default mcp command when none provided', async () => {
+            mockedExecAsync
+                .mockResolvedValueOnce({ stdout: 'claude version 1.0.0', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupClaudeCode();
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith(expect.stringContaining('claude mcp add-json "HubSpotDev"'));
+        });
+        it('should return false when claude command is not found', async () => {
+            mockedExecAsync.mockRejectedValueOnce(new Error('claude: command not found'));
+            const result = await setupClaudeCode(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('claudeCode', {
+                text: commands.mcp.setup.spinners.claudeCodeNotFound,
+            });
+        });
+        it('should return false and log error when mcp add fails', async () => {
+            const error = new Error('mcp add failed');
+            mockedExecAsync
+                .mockResolvedValueOnce({ stdout: 'claude version 1.0.0', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' })
+                .mockRejectedValueOnce(error);
+            const result = await setupClaudeCode(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('claudeCode', {
+                text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+    });
+    describe('setupCursor', () => {
+        const mockedFs = vi.mocked(fs);
+        const mockedExistsSync = vi.mocked(existsSync);
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1'],
+        };
+        beforeEach(() => {
+            vi.mocked(os.homedir).mockReturnValue('/home/user');
+            vi.mocked(path.join).mockImplementation((...parts) => parts.join('/'));
+        });
+        it('should successfully configure Cursor when config file exists', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify({ mcpServers: { existingServer: {} } }));
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('.cursor/mcp.json'), expect.stringContaining('HubSpotDev'));
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.configuredCursor,
+            });
+        });
+        it('should create config file when it does not exist', () => {
+            mockedExistsSync.mockReturnValue(false);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('.cursor/mcp.json'), JSON.stringify({}, null, 2));
+        });
+        it('should handle empty config file', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('   ');
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(true);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            expect(writeCall).toBeDefined();
+        });
+        it('should return false when config file has invalid JSON', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('not valid json {{{');
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.failedToConfigureCursor,
+            });
+        });
+        it('should return false when reading config file fails', () => {
+            const error = new Error('Permission denied');
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockImplementation(() => {
+                throw error;
+            });
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.failedToConfigureCursor,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+        it('should use default mcp command when none provided', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = setupCursor();
+            expect(result).toBe(true);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            const written = JSON.parse(writeCall[1]);
+            expect(written.mcpServers.HubSpotDev.command).toBe('hs');
+        });
+        it('should initialize mcpServers when missing from existing config', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify({ someOtherKey: true }));
+            const result = setupCursor(mockMcpCommand);
+            expect(result).toBe(true);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            const written = JSON.parse(writeCall[1]);
+            expect(written.mcpServers).toBeDefined();
+            expect(written.mcpServers.HubSpotDev).toBeDefined();
+        });
+    });
+    describe('setupWindsurf', () => {
+        const mockedFs = vi.mocked(fs);
+        const mockedExistsSync = vi.mocked(existsSync);
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1'],
+        };
+        beforeEach(() => {
+            vi.mocked(os.homedir).mockReturnValue('/home/user');
+            vi.mocked(path.join).mockImplementation((...parts) => parts.join('/'));
+        });
+        it('should successfully configure Windsurf', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = setupWindsurf(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.configuringWindsurf,
+            });
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('.codeium/windsurf/mcp_config.json'), expect.stringContaining('HubSpotDev'));
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.configuredWindsurf,
+            });
+        });
+        it('should create config file when it does not exist', () => {
+            mockedExistsSync.mockReturnValue(false);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = setupWindsurf(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('.codeium/windsurf/mcp_config.json'), JSON.stringify({}, null, 2));
+        });
+        it('should return false on invalid JSON', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{ invalid json');
+            const result = setupWindsurf(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('spinner', {
+                text: commands.mcp.setup.spinners.failedToConfigureWindsurf,
+            });
+        });
+        it('should use default mcp command when none provided', () => {
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = setupWindsurf();
+            expect(result).toBe(true);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            const written = JSON.parse(writeCall[1]);
+            expect(written.mcpServers.HubSpotDev.command).toBe('hs');
+        });
+    });
+    describe('setupVsCode', () => {
+        const mockMcpCommand = {
+            command: 'test-command',
+            args: ['--arg1'],
+        };
+        it('should successfully configure VS Code', async () => {
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupVsCode(mockMcpCommand);
+            expect(result).toBe(true);
+            expect(mockedSpinniesManager.add).toHaveBeenCalledWith('vsCode', {
+                text: commands.mcp.setup.spinners.configuringVsCode,
+            });
+            expect(mockedExecAsync).toHaveBeenCalledWith(expect.stringContaining('code --add-mcp'));
+            expect(mockedSpinniesManager.succeed).toHaveBeenCalledWith('vsCode', {
+                text: commands.mcp.setup.spinners.configuredVsCode,
+            });
+        });
+        it('should use default mcp command when none provided', async () => {
+            mockedExecAsync.mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await setupVsCode();
+            expect(result).toBe(true);
+            expect(mockedExecAsync).toHaveBeenCalledWith(expect.stringContaining('code --add-mcp'));
+        });
+        it('should return false when code command is not found', async () => {
+            mockedExecAsync.mockRejectedValueOnce(new Error('code: command not found'));
+            const result = await setupVsCode(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('vsCode', {
+                text: commands.mcp.setup.spinners.vsCodeNotFound,
+            });
+            expect(mockedLogError).not.toHaveBeenCalled();
+        });
+        it('should return false and log error on other failures', async () => {
+            const error = new Error('Unexpected failure');
+            mockedExecAsync.mockRejectedValueOnce(error);
+            const result = await setupVsCode(mockMcpCommand);
+            expect(result).toBe(false);
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('vsCode', {
+                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
+            });
+            expect(mockedLogError).toHaveBeenCalledWith(error);
+        });
+    });
+    describe('addMcpServerToConfig', () => {
+        const mockedPromptUser = vi.mocked(promptUser);
+        const mockedExistsSync = vi.mocked(existsSync);
+        const mockedFs = vi.mocked(fs);
+        const mockedUiLogger = vi.mocked(uiLogger);
+        beforeEach(() => {
+            vi.mocked(os.homedir).mockReturnValue('/home/user');
+            vi.mocked(path.join).mockImplementation((...parts) => parts.join('/'));
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+        });
+        it('should use provided targets without prompting', async () => {
+            mockedPromptUser.mockResolvedValueOnce({ useStandaloneMode: false });
+            mockedExecAsync
+                .mockResolvedValueOnce({ stdout: '', stderr: '' })
+                .mockResolvedValueOnce({ stdout: '', stderr: '' });
+            const result = await addMcpServerToConfig(['cursor']);
+            expect(result).toEqual(['cursor']);
+            expect(mockedPromptUser).not.toHaveBeenCalledWith(expect.objectContaining({ name: 'selectedTargets' }));
+        });
+        it('should prompt for targets when none provided', async () => {
+            mockedPromptUser
+                .mockResolvedValueOnce({ selectedTargets: ['cursor'] })
+                .mockResolvedValueOnce({ useStandaloneMode: false });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = await addMcpServerToConfig(undefined);
+            expect(result).toEqual(['cursor']);
+            expect(mockedPromptUser).toHaveBeenCalledWith(expect.objectContaining({ name: 'selectedTargets' }));
+        });
+        it('should prompt for targets when empty array provided', async () => {
+            mockedPromptUser
+                .mockResolvedValueOnce({ selectedTargets: ['windsurf'] })
+                .mockResolvedValueOnce({ useStandaloneMode: false });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = await addMcpServerToConfig([]);
+            expect(result).toEqual(['windsurf']);
+            expect(mockedPromptUser).toHaveBeenCalledWith(expect.objectContaining({ name: 'selectedTargets' }));
+        });
+        it('should use npx command in standalone mode', async () => {
+            mockedPromptUser
+                .mockResolvedValueOnce({ useStandaloneMode: true })
+                .mockResolvedValueOnce({ cliVersion: '' });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = await addMcpServerToConfig(['cursor']);
+            expect(result).toEqual(['cursor']);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            const written = JSON.parse(writeCall[1]);
+            expect(written.mcpServers.HubSpotDev.command).toBe('npx');
+            expect(written.mcpServers.HubSpotDev.env?.HUBSPOT_MCP_STANDALONE).toBe('true');
+        });
+        it('should pin version in standalone mode when version is provided', async () => {
+            mockedPromptUser
+                .mockResolvedValueOnce({ useStandaloneMode: true })
+                .mockResolvedValueOnce({ cliVersion: '8.0.1' });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = await addMcpServerToConfig(['cursor']);
+            expect(result).toEqual(['cursor']);
+            const writeCall = mockedFs.writeFileSync.mock.calls.find(c => c[1].includes('HubSpotDev'));
+            const written = JSON.parse(writeCall[1]);
+            expect(written.mcpServers.HubSpotDev.args).toContain('@hubspot/cli@8.0.1');
+            expect(written.mcpServers.HubSpotDev.env?.HUBSPOT_CLI_VERSION).toBe('8.0.1');
+        });
+        it('should call success logger after all targets are configured', async () => {
+            mockedPromptUser.mockResolvedValueOnce({ useStandaloneMode: false });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            await addMcpServerToConfig(['cursor', 'windsurf']);
+            expect(mockedUiLogger.info).toHaveBeenCalledWith(commands.mcp.setup.success(['cursor', 'windsurf']));
+        });
+        it('should throw and fail spinner when setup function returns false', async () => {
+            mockedPromptUser.mockResolvedValueOnce({ useStandaloneMode: false });
+            const error = new Error('Permission denied');
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockImplementation(() => {
+                throw error;
+            });
+            await expect(addMcpServerToConfig(['cursor'])).rejects.toThrow();
+            expect(mockedSpinniesManager.fail).toHaveBeenCalledWith('mcpSetup', {
+                text: commands.mcp.setup.spinners.failedToConfigure,
+            });
+        });
+        it('should configure multiple targets', async () => {
+            mockedPromptUser.mockResolvedValueOnce({ useStandaloneMode: false });
+            mockedExistsSync.mockReturnValue(true);
+            mockedFs.readFileSync.mockReturnValue('{}');
+            const result = await addMcpServerToConfig(['cursor', 'windsurf']);
+            expect(result).toEqual(['cursor', 'windsurf']);
+        });
+    });
+});

package/lib/middleware/__tests__/commandTargetingUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__tests__/commandTargetingUtils.test.js

@@ -0,0 +1,99 @@
+import * as cliConfig from '@hubspot/local-dev-lib/config';
+import { isTargetedCommand, shouldLoadConfigForCommand, shouldRunAccountValidationForCommand, shouldRunConfigValidationForCommand, } from '../commandTargetingUtils.js';
+vi.mock('@hubspot/local-dev-lib/config');
+const globalConfigFileExistsSpy = vi.spyOn(cliConfig, 'globalConfigFileExists');
+const targetCommandMap = {
+    init: true,
+    account: {
+        use: true,
+    },
+    project: {
+        deploy: true,
+    },
+};
+describe('lib/middleware/commandTargetingUtils', () => {
+    describe('isTargetedCommand()', () => {
+        it('should return true for a direct target command', () => {
+            const result = isTargetedCommand(['init'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command with a subcommand', () => {
+            const result = isTargetedCommand(['account'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return true for a nested target command', () => {
+            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a non-existent command', () => {
+            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-targeted command', () => {
+            const result = isTargetedCommand(['auth'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a command with a targeted subcommand', () => {
+            const result = isTargetedCommand(['project'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-existent subcommand', () => {
+            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for an empty command array', () => {
+            const result = isTargetedCommand([], targetCommandMap);
+            expect(result).toBe(false);
+        });
+    });
+    describe('shouldLoadConfigForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require a config file', () => {
+            const result = shouldLoadConfigForCommand(['init']);
+            expect(result).toBe(false);
+        });
+        it('should return false when the user is trying to migrate the global config', () => {
+            globalConfigFileExistsSpy.mockReturnValue(false);
+            const result = shouldLoadConfigForCommand(['config', 'migrate']);
+            expect(result).toBe(false);
+        });
+        it('should return true when the global config file does exist', () => {
+            globalConfigFileExistsSpy.mockReturnValue(true);
+            const result = shouldLoadConfigForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+    });
+    describe('shouldRunAccountValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunAccountValidationForCommand([
+                'project',
+                'upload',
+            ]);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require account validation', () => {
+            const result1 = shouldRunAccountValidationForCommand(['init']);
+            const result2 = shouldRunAccountValidationForCommand(['auth']);
+            const result3 = shouldRunAccountValidationForCommand([
+                'accounts',
+                'list',
+            ]);
+            expect(result1).toBe(false);
+            expect(result2).toBe(false);
+            expect(result3).toBe(false);
+        });
+    });
+    describe('shouldRunConfigValidationForCommand()', () => {
+        it('should return true for a command that requires a config file', () => {
+            const result = shouldRunConfigValidationForCommand(['account', 'use']);
+            expect(result).toBe(true);
+        });
+        it('should return false for a command that does not require config validation', () => {
+            const result = shouldRunConfigValidationForCommand(['init']);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/middleware/__tests__/configMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};