@hubspot/cli 8.1.0 → 8.2.0

package/lib/commandSuggestion.js

@@ -18,12 +18,6 @@ export const commandSuggestionMappings = {
     'theme generate-selectors': 'hs cms theme generate-selectors',
     'theme marketplace-validate': 'hs cms theme marketplace-validate',
     'theme preview': 'hs cms theme preview',
-    'custom-object schema create': 'hs custom-object create-schema',
-    'custom-object schema delete': 'hs custom-object delete-schema',
-    'custom-object schema fetch-all': 'hs custom-object fetch-all-schemas',
-    'custom-object schema fetch': 'hs custom-object fetch-schema',
-    'custom-object schema list': 'hs custom-object list-schemas',
-    'custom-object schema update': 'hs custom-object update-schema',
 };
 function createCommandSuggestionHandler(newCommand) {
     return () => {
@@ -35,7 +29,7 @@ function createCommandSuggestion(oldCommand, newCommand) {
     return {
         command: oldCommand,
         builder: async (yargs) => {
-            return yargs.strict(false);
+            return yargs.strict(false).help(false).version(false);
         },
         handler: createCommandSuggestionHandler(newCommand),
     };

package/lib/constants.d.ts

@@ -81,7 +81,6 @@ export declare const FEATURES: {
     readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
     readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
     readonly APPS_HOME: "UIE:AppHome";
-    readonly MCP_ACCESS: "Developers:CLIMCPAccess";
     readonly THEME_MIGRATION_2025_2: "Developers:ProjectThemeMigrations:2025.2";
     readonly AGENT_TOOLS: "ThirdPartyAgentTools";
 };
@@ -145,3 +144,4 @@ export declare const ACCOUNT_LEVELS: {
     readonly ENTERPRISE: "ENTERPRISE";
 };
 export declare const ACCOUNT_LEVEL_CHOICES: readonly ["FREE", "STARTER", "PROFESSIONAL", "ENTERPRISE"];
+export declare const FEEDBACK_URL = "https://developers.hubspot.com/feedback";

package/lib/constants.js

@@ -73,7 +73,6 @@ export const FEATURES = {
     SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
     APPS_HOME: 'UIE:AppHome',
-    MCP_ACCESS: 'Developers:CLIMCPAccess',
     THEME_MIGRATION_2025_2: 'Developers:ProjectThemeMigrations:2025.2',
     AGENT_TOOLS: 'ThirdPartyAgentTools',
 };
@@ -146,3 +145,4 @@ export const ACCOUNT_LEVEL_CHOICES = [
     ACCOUNT_LEVELS.PROFESSIONAL,
     ACCOUNT_LEVELS.ENTERPRISE,
 ];
+export const FEEDBACK_URL = 'https://developers.hubspot.com/feedback';

package/lib/generateSelectors.js

@@ -1,5 +1,4 @@
 import fs from 'fs';
-import { EXIT_CODES } from './enums/exitCodes.js';
 import { commands } from '../lang/en.js';
 import { uiLogger } from './ui/logger.js';
 const CSS_COMMENTS_REGEX = new RegExp(/\/\*.*\*\//, 'g');
@@ -12,7 +11,7 @@ export function findFieldsJsonPath(basePath) {
     const _path = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
     if (!fs.existsSync(_path)) {
         uiLogger.error(commands.cms.subcommands.theme.subcommands.generateSelectors.errors.invalidPath(basePath));
-        process.exit(EXIT_CODES.ERROR);
+        return null;
     }
     const files = fs.readdirSync(_path);
     if (files.includes('fields.json')) {

package/lib/getStartedV2Actions.d.ts

@@ -35,3 +35,16 @@ export declare function uploadAndDeployAction({ accountId, projectDest, }: {
     projectDest: string;
 }): Promise<UploadAndDeployResult>;
 export declare function trackGetStartedUsage(params: Record<string, unknown>, accountId: number): Promise<void>;
+export type PollAppInstallationOptions = {
+    accountId: number;
+    projectId: number;
+    appUid: string;
+    requiredScopes?: string[];
+    optionalScopes?: string[];
+    timeoutMs?: number;
+    intervalMs?: number;
+    onTimeout?: () => void;
+};
+export declare function pollAppInstallation({ accountId, projectId, appUid, requiredScopes, optionalScopes, timeoutMs, // 2 minutes
+intervalMs, // 2 seconds
+onTimeout, }: PollAppInstallationOptions): Promise<void>;

package/lib/getStartedV2Actions.js

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
 import { getConfigAccountEnvironment } from '@hubspot/local-dev-lib/config';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
@@ -144,3 +145,55 @@ export async function uploadAndDeployAction({ accountId, projectDest, }) {
 export function trackGetStartedUsage(params, accountId) {
     return trackCommandMetadataUsage('get-started', params, accountId);
 }
+export async function pollAppInstallation({ accountId, projectId, appUid, requiredScopes = [], optionalScopes = [], timeoutMs = 2 * 60 * 1000, // 2 minutes
+intervalMs = 2000, // 2 seconds
+onTimeout, }) {
+    return new Promise((resolve, reject) => {
+        let consecutiveErrors = 0;
+        const MAX_CONSECUTIVE_ERRORS = 5;
+        let pollInterval = null;
+        let pollTimeout = null;
+        const cleanup = () => {
+            if (pollInterval) {
+                clearTimeout(pollInterval);
+                pollInterval = null;
+            }
+            if (pollTimeout) {
+                clearTimeout(pollTimeout);
+                pollTimeout = null;
+            }
+        };
+        pollTimeout = setTimeout(() => {
+            cleanup();
+            if (onTimeout) {
+                onTimeout();
+            }
+            resolve(); // Resolve instead of reject to allow continuing with timeout state
+        }, timeoutMs);
+        const poll = async () => {
+            try {
+                const { data } = await fetchAppInstallationData(accountId, projectId, appUid, requiredScopes, optionalScopes);
+                // Reset error counter on successful fetch
+                consecutiveErrors = 0;
+                if (data.isInstalledWithScopeGroups) {
+                    cleanup();
+                    resolve();
+                }
+                else if (pollInterval) {
+                    pollInterval = setTimeout(poll, intervalMs);
+                }
+            }
+            catch (error) {
+                consecutiveErrors++;
+                if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                    cleanup();
+                    reject(new Error(`Failed to check app installation status after ${MAX_CONSECUTIVE_ERRORS} consecutive errors`, { cause: error }));
+                }
+                else if (pollInterval !== null) {
+                    pollInterval = setTimeout(poll, intervalMs);
+                }
+            }
+        };
+        pollInterval = setTimeout(poll, 0);
+    });
+}

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>;