@hubspot/cli 8.0.10-experimental.1 → 8.0.10-experimental.2

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

@@ -1,37 +1,24 @@
 import { execAsync } from '../../../mcp-server/utils/command.js';
-import { setupCodex, setupGemini, supportedTools } from '../setup.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('../../../lang/en.js', () => ({
-    commands: {
-        mcp: {
-            setup: {
-                codex: 'Codex CLI',
-                claudeCode: 'Claude Code',
-                cursor: 'Cursor',
-                gemini: 'Gemini CLI',
-                vsCode: 'VS Code',
-                windsurf: 'Windsurf',
-                success: vi.fn(targets => `Success message for ${targets.join(', ')}`),
-                spinners: {
-                    configuringCodex: 'Configuring Codex...',
-                    configuredCodex: 'Configured Codex',
-                    codexNotFound: 'Codex command not found - skipping configuration',
-                    codexInstallFailed: 'Failed to configure Codex',
-                    configuringGemini: 'Configuring Gemini CLI...',
-                    configuredGemini: 'Configured Gemini CLI',
-                    geminiNotFound: 'Gemini CLI not found - skipping configuration',
-                    geminiInstallFailed: 'Failed to configure Gemini CLI',
-                },
-            },
-        },
-    },
-}));
+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);
@@ -132,6 +119,21 @@ describe('lib/mcp/setup', () => {
             });
             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 = {
@@ -189,6 +191,333 @@ describe('lib/mcp/setup', () => {
             expect(mockedLogError).toHaveBeenCalledWith(error);
         });
     });
-    // Note: addMcpServerToConfig integration tests would require mocking many dependencies
-    // and complex setup. The setupCodex function tests above cover the new functionality.
+    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/mcp/setup.d.ts

@@ -5,6 +5,7 @@ export declare const supportedTools: {
 interface McpCommand {
     command: string;
     args: string[];
+    env?: Record<string, string>;
 }
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
 export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;

package/lib/mcp/setup.js

@@ -47,23 +47,56 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
+        // Prompt for standalone mode
+        const { useStandaloneMode } = await promptUser({
+            name: 'useStandaloneMode',
+            type: 'confirm',
+            message: commands.mcp.setup.prompts.standaloneMode,
+            default: false,
+        });
+        const { cliVersion } = useStandaloneMode
+            ? await promptUser({
+                name: 'cliVersion',
+                type: 'input',
+                message: commands.mcp.setup.prompts.cliVersion,
+                validate: (v) => !v || /^[\d]+\.[\d]+\.[\d]+([-+][\w.]+)?$/.test(v.trim())
+                    ? true
+                    : 'Please enter a valid semver version (e.g. 8.0.1) or leave blank for latest.',
+            })
+            : { cliVersion: '' };
+        const cliPackage = cliVersion
+            ? `@hubspot/cli@${cliVersion}`
+            : '@hubspot/cli';
+        const standaloneEnv = {
+            HUBSPOT_MCP_STANDALONE: 'true',
+        };
+        if (cliVersion) {
+            standaloneEnv.HUBSPOT_CLI_VERSION = cliVersion;
+        }
+        const mcpCommand = useStandaloneMode
+            ? {
+                command: 'npx',
+                args: ['-y', '-p', cliPackage, 'hs', 'mcp', 'start'],
+                env: standaloneEnv,
+            }
+            : defaultMcpCommand;
         if (derivedTargets.includes(claudeCode)) {
-            await runSetupFunction(setupClaudeCode);
+            await runSetupFunction(() => setupClaudeCode(mcpCommand));
         }
         if (derivedTargets.includes(cursor)) {
-            await runSetupFunction(setupCursor);
+            await runSetupFunction(() => setupCursor(mcpCommand));
         }
         if (derivedTargets.includes(windsurf)) {
-            await runSetupFunction(setupWindsurf);
+            await runSetupFunction(() => setupWindsurf(mcpCommand));
         }
         if (derivedTargets.includes(vscode)) {
-            await runSetupFunction(setupVsCode);
+            await runSetupFunction(() => setupVsCode(mcpCommand));
         }
         if (derivedTargets.includes(codex)) {
-            await runSetupFunction(setupCodex);
+            await runSetupFunction(() => setupCodex(mcpCommand));
         }
         if (derivedTargets.includes(gemini)) {
-            await runSetupFunction(setupGemini);
+            await runSetupFunction(() => setupGemini(mcpCommand));
         }
         uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
@@ -121,10 +154,7 @@ function setupMcpConfigFile(config) {
         if (!mcpConfig.mcpServers) {
             mcpConfig.mcpServers = {};
         }
-        // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
-        };
+        mcpConfig.mcpServers[mcpServerName] = config.mcpCommand;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -145,10 +175,12 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('vsCode', {
             text: commands.mcp.setup.spinners.configuringVsCode,
         });
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, vscode);
+        const configObject = {
             name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -172,25 +204,27 @@ export async function setupVsCode(mcpCommand = defaultMcpCommand) {
     }
 }
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+    SpinniesManager.add('claudeCode', {
+        text: commands.mcp.setup.spinners.configuringClaudeCode,
+    });
     try {
-        SpinniesManager.add('claudeCode', {
-            text: commands.mcp.setup.spinners.configuringClaudeCode,
+        // Check if claude command is available
+        await execAsync('claude --version');
+    }
+    catch (e) {
+        SpinniesManager.fail('claudeCode', {
+            text: commands.mcp.setup.spinners.claudeCodeNotFound,
         });
-        try {
-            // Check if claude command is available
-            await execAsync('claude --version');
-        }
-        catch (e) {
-            SpinniesManager.fail('claudeCode', {
-                text: commands.mcp.setup.spinners.claudeCodeNotFound,
-            });
-            return false;
-        }
+        return false;
+    }
+    try {
         // Run claude mcp add command
-        const mcpConfig = JSON.stringify({
+        const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
+        const configObject = {
             type: 'stdio',
-            ...buildCommandWithAgentString(mcpCommand, claudeCode),
-        });
+            ...commandWithAgent,
+        };
+        const mcpConfig = JSON.stringify(configObject);
         const { stdout } = await execAsync('claude mcp list');
         if (stdout.includes(mcpServerName)) {
             SpinniesManager.update('claudeCode', {
@@ -248,7 +282,7 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
-        await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`codex mcp add "${mcpServerName}"${buildEnvFlagString(mcpCommand)} -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
             text: commands.mcp.setup.spinners.configuredCodex,
         });
@@ -277,7 +311,7 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
             return false;
         }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
-        await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
+        await execAsync(`gemini mcp add -s user${buildEnvFlagString(mcpCommand)} "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuredGemini,
         });
@@ -296,3 +330,16 @@ function buildCommandWithAgentString(mcpCommand, agent) {
     mcpCommandCopy.args.push('--ai-agent', agent);
     return mcpCommandCopy;
 }
+function buildEnvFlagString(mcpCommand) {
+    const envFlags = [];
+    if (mcpCommand.env) {
+        const env = Object.entries(mcpCommand.env);
+        env.forEach(([key, value]) => {
+            envFlags.push(`--env ${key}="${value}"`);
+        });
+    }
+    if (envFlags.length === 0) {
+        return '';
+    }
+    return ` ${envFlags.join(' ')}`;
+}

package/lib/projects/create/__tests__/legacy.test.js

@@ -1,6 +1,4 @@
-import { uiLogger } from '../../../ui/logger.js';
 import * as github from '@hubspot/local-dev-lib/api/github';
-import { EXIT_CODES } from '../../../enums/exitCodes.js';
 import { getProjectComponentListFromRepo, getProjectTemplateListFromRepo, } from '../legacy.js';
 import { PROJECT_COMPONENT_TYPES, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../../../constants.js';
 vi.mock('@hubspot/local-dev-lib/api/github');
@@ -38,16 +36,6 @@ describe('lib/projects/create/legacy', () => {
         });
     });
     describe('getProjectTemplateListFromRepo()', () => {
-        let exitMock;
-        beforeEach(() => {
-            // @ts-expect-error - Mocking process.exit
-            exitMock = vi
-                .spyOn(process, 'exit')
-                .mockImplementation(() => undefined);
-        });
-        afterEach(() => {
-            exitMock.mockRestore();
-        });
         it('returns a list of project templates', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({
@@ -56,20 +44,16 @@ describe('lib/projects/create/legacy', () => {
             const templates = await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
             expect(templates).toEqual(repoConfig[PROJECT_COMPONENT_TYPES.PROJECTS]);
         });
-        it('Logs an error and exits the process if the request for the template list fails', async () => {
+        it('throws an error if the request for the template list fails', async () => {
             mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Failed to fetch the config.json file from the target repository/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Failed to fetch the config.json file from the target repository');
         });
-        it('Logs an error and exits the process if there are no projects listed in the repo config', async () => {
+        it('throws an error if there are no projects listed in the repo config', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({});
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to find any projects in the target repository's config.json file/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Unable to find any projects in the target repository');
         });
-        it('Logs an error and exits the process if any of the projects in the repo config are missing required properties', async () => {
+        it('throws an error if any of the projects in the repo config are missing required properties', async () => {
             // @ts-expect-error - Mocking AxiosResponse
             mockedFetchRepoFile.mockResolvedValue({
                 data: {
@@ -82,9 +66,7 @@ describe('lib/projects/create/legacy', () => {
                     ],
                 },
             });
-            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
-            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Found misconfigured projects in the target repository's config.json file/));
-            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Found misconfigured projects in the target repository');
         });
     });
 });

package/lib/projects/create/index.js

@@ -4,9 +4,7 @@ import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH
 import { isV2Project } from '../platformVersion.js';
 import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
-import { uiLogger } from '../../ui/logger.js';
 import { commands } from '../../../lang/en.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
 export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
@@ -25,8 +23,7 @@ export async function handleProjectCreationFlow(args) {
     }
     const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     if (!projectTemplates.length) {
-        uiLogger.error(commands.project.create.errors.failedToFetchProjectList);
-        process.exit(EXIT_CODES.ERROR);
+        throw new Error(commands.project.create.errors.failedToFetchProjectList);
     }
     const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
     return {