@hubspot/cli 8.0.0 → 8.0.1-experimental.0

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

@@ -7,14 +7,20 @@ import * as errorHandlers from '../../../lib/errorHandlers/index.js';
 import * as usageTrackingLib from '../../../lib/usageTracking.js';
 import * as processLib from '../../../lib/process.js';
 import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import startCommand from '../start.js';
+// Create a mock execAsync function before importing the module
+const execAsyncMock = vi.fn();
 vi.mock('yargs');
 vi.mock('../../../lib/commonOpts');
 vi.mock('node:child_process');
+vi.mock('node:util', () => ({
+    promisify: vi.fn(() => execAsyncMock),
+}));
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../../../lib/errorHandlers/index.js');
 vi.mock('../../../lib/process.js');
+// Import after mocks are set up
+const startCommand = await import('../start.js').then(m => m.default);
 const spawnSpy = vi.mocked(spawn);
 const existsSyncSpy = vi.spyOn(fs, 'existsSync');
 const trackCommandUsageSpy = vi.spyOn(usageTrackingLib, 'trackCommandUsage');
@@ -36,6 +42,7 @@ describe('commands/mcp/start', () => {
         processExitSpy.mockImplementation(() => { });
         // Mock config to prevent reading actual config file in CI
         getConfigAccountIfExistsSpy.mockReturnValue(undefined);
+        execAsyncMock.mockClear();
     });
     describe('command', () => {
         it('should have the correct command structure', () => {
@@ -133,5 +140,64 @@ describe('commands/mcp/start', () => {
             expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('Failed to start'));
             expect(logErrorSpy).toHaveBeenCalledWith(error);
         });
+        it('should fetch CLI version in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            execAsyncMock.mockResolvedValue({
+                stdout: '8.0.0',
+                stderr: '',
+            });
+            await startCommand.handler(args);
+            expect(execAsyncMock).toHaveBeenCalledWith('npm view @hubspot/cli version');
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.objectContaining({
+                    HUBSPOT_CLI_VERSION: '8.0.0',
+                }),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should not fetch CLI version when not in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            delete process.env.HUBSPOT_MCP_STANDALONE;
+            await startCommand.handler(args);
+            expect(execAsyncMock).not.toHaveBeenCalled();
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.not.objectContaining({
+                    HUBSPOT_CLI_VERSION: expect.anything(),
+                }),
+            }));
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should handle version fetch errors gracefully', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const error = new Error('Version fetch failed');
+            execAsyncMock.mockRejectedValue(error);
+            await startCommand.handler(args);
+            expect(execAsyncMock).toHaveBeenCalledWith('npm view @hubspot/cli version');
+            expect(uiLogger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to get CLI version'));
+            expect(logErrorSpy).toHaveBeenCalledWith(error);
+            expect(spawnSpy).toHaveBeenCalledWith('node', expect.any(Array), expect.objectContaining({
+                env: expect.not.objectContaining({
+                    HUBSPOT_CLI_VERSION: expect.anything(),
+                }),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
     });
 });

package/commands/mcp/start.js

@@ -1,4 +1,5 @@
-import { spawn } from 'node:child_process';
+import { spawn, exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import path from 'path';
 import fs from 'fs';
 import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
@@ -9,6 +10,7 @@ import { commands } from '../../lang/en.js';
 import { handleExit } from '../../lib/process.js';
 import { trackCommandUsage } from '../../lib/usageTracking.js';
 import { fileURLToPath } from 'url';
+const execAsync = promisify(exec);
 const command = 'start';
 const describe = undefined; // Leave hidden for now
 const __filename = fileURLToPath(import.meta.url);
@@ -28,12 +30,28 @@ async function startMcpServer(aiAgent) {
         uiLogger.debug(commands.mcp.start.startingServer);
         uiLogger.debug(commands.mcp.start.stopInstructions);
         const args = [serverPath];
+        // Get CLI version if running in standalone mode
+        let cliVersion;
+        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
+            try {
+                // const { stdout } = await execAsync('npm view @hubspot/cli version');
+                // // Extract version number from output (e.g., "8.0.0")
+                // cliVersion = stdout.trim();
+                cliVersion = '8.0.1-experimental.0';
+                uiLogger.debug(`Using @hubspot/cli version: ${cliVersion}`);
+            }
+            catch (error) {
+                uiLogger.warn('Failed to get CLI version, will use latest');
+                logError(error);
+            }
+        }
         // Start the server using ts-node
         const child = spawn(`node`, args, {
             stdio: 'inherit',
             env: {
                 ...process.env,
                 HUBSPOT_MCP_AI_AGENT: aiAgent || 'unknown',
+                ...(cliVersion && { HUBSPOT_CLI_VERSION: cliVersion }),
             },
         });
         // Handle server process events

package/lang/en.d.ts

@@ -1246,6 +1246,7 @@ export declare const commands: {
             prompts: {
                 targets: string;
                 targetsRequired: string;
+                standaloneMode: string;
             };
         };
         start: {

package/lang/en.js

@@ -1262,6 +1262,7 @@ export const commands = {
             prompts: {
                 targets: '[--client] Which tools would you like to add the HubSpot CLI MCP server to?',
                 targetsRequired: 'Must choose at least one app to configure.',
+                standaloneMode: 'Do you want to run in standalone mode? (This will use npx @hubspot/cli instead of local hs command)',
             },
         },
         start: {

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

@@ -132,6 +132,23 @@ 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);
+            // The env is passed through buildCommandWithAgentString, but not used in the command string
+            // This is expected as env vars are set by the client when starting the MCP server
+            expect(mockedExecAsync).toHaveBeenCalledWith('codex mcp add "HubSpotDev" -- test-command --arg1 --ai-agent codex');
+        });
     });
     describe('setupGemini', () => {
         const mockMcpCommand = {

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,44 @@ 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 mcpCommand = useStandaloneMode
+            ? {
+                command: 'npx',
+                args: [
+                    '-y',
+                    '-p',
+                    '@hubspot/cli@8.0.1-experimental.0',
+                    'hs',
+                    'mcp',
+                    'start',
+                ],
+                env: { HUBSPOT_MCP_STANDALONE: 'true' },
+            }
+            : 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;
@@ -122,9 +143,14 @@ function setupMcpConfigFile(config) {
             mcpConfig.mcpServers = {};
         }
         // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
+        const serverConfig = {
+            command: config.mcpCommand.command,
+            args: config.mcpCommand.args,
         };
+        if (config.mcpCommand.env) {
+            serverConfig.env = config.mcpCommand.env;
+        }
+        mcpConfig.mcpServers[mcpServerName] = serverConfig;
         // Write the updated config
         fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
         SpinniesManager.succeed('spinner', {
@@ -145,10 +171,16 @@ 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),
-        });
+            command: commandWithAgent.command,
+            args: commandWithAgent.args,
+        };
+        if (commandWithAgent.env) {
+            configObject.env = commandWithAgent.env;
+        }
+        const mcpConfig = JSON.stringify(configObject);
         await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
         SpinniesManager.succeed('vsCode', {
             text: commands.mcp.setup.spinners.configuredVsCode,
@@ -180,10 +212,16 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
             // Check if claude command is available
             await execAsync('claude --version');
             // Run claude mcp add command
-            const mcpConfig = JSON.stringify({
+            const commandWithAgent = buildCommandWithAgentString(mcpCommand, claudeCode);
+            const configObject = {
                 type: 'stdio',
-                ...buildCommandWithAgentString(mcpCommand, claudeCode),
-            });
+                command: commandWithAgent.command,
+                args: commandWithAgent.args,
+            };
+            if (commandWithAgent.env) {
+                configObject.env = commandWithAgent.env;
+            }
+            const mcpConfig = JSON.stringify(configObject);
             const { stdout } = await execAsync('claude mcp list');
             if (stdout.includes(mcpServerName)) {
                 SpinniesManager.update('claudeCode', {

package/mcp-server/utils/__tests__/project.test.js

@@ -136,5 +136,130 @@ describe('mcp-server/utils/project', () => {
                 env: expect.any(Object),
             }));
         });
+        it('should use npx -p @hubspot/cli when HUBSPOT_MCP_STANDALONE is true', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use regular hs command when HUBSPOT_MCP_STANDALONE is not set', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            delete process.env.HUBSPOT_MCP_STANDALONE;
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use npx -p @hubspot/cli for hs commands with flags in standalone mode', async () => {
+            const originalEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            const hsCommand = 'hs project upload --profile prod';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalEnv;
+            }
+        });
+        it('should use pinned CLI version when HUBSPOT_CLI_VERSION is set in standalone mode', async () => {
+            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            process.env.HUBSPOT_CLI_VERSION = '8.0.0';
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli@8.0.0 hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalStandaloneEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
+            }
+            if (originalVersionEnv === undefined) {
+                delete process.env.HUBSPOT_CLI_VERSION;
+            }
+            else {
+                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
+            }
+        });
+        it('should use latest CLI version when HUBSPOT_CLI_VERSION is not set in standalone mode', async () => {
+            const originalStandaloneEnv = process.env.HUBSPOT_MCP_STANDALONE;
+            const originalVersionEnv = process.env.HUBSPOT_CLI_VERSION;
+            process.env.HUBSPOT_MCP_STANDALONE = 'true';
+            delete process.env.HUBSPOT_CLI_VERSION;
+            const hsCommand = 'hs project upload';
+            const expectedResult = {
+                stdout: 'success',
+                stderr: '',
+            };
+            mockExistsSync.mockReturnValue(true);
+            mockExecAsync.mockResolvedValue(expectedResult);
+            await runCommandInDir(mockDirectory, hsCommand);
+            expect(mockExecAsync).toHaveBeenCalledWith('npx -p @hubspot/cli hs project upload --disable-usage-tracking "true"', expect.objectContaining({
+                cwd: mockResolvedPath,
+                env: expect.any(Object),
+            }));
+            // Restore original env
+            if (originalStandaloneEnv === undefined) {
+                delete process.env.HUBSPOT_MCP_STANDALONE;
+            }
+            else {
+                process.env.HUBSPOT_MCP_STANDALONE = originalStandaloneEnv;
+            }
+            if (originalVersionEnv !== undefined) {
+                process.env.HUBSPOT_CLI_VERSION = originalVersionEnv;
+            }
+        });
     });
 });

package/mcp-server/utils/project.js

@@ -7,6 +7,14 @@ export async function runCommandInDir(directory, command) {
     }
     let finalCommand = command;
     if (command.startsWith('hs ')) {
+        // Check if running in standalone mode
+        if (process.env.HUBSPOT_MCP_STANDALONE === 'true') {
+            // Use pinned version if available, otherwise use latest
+            const cliPackage = process.env.HUBSPOT_CLI_VERSION
+                ? `@hubspot/cli@8.0.1-experimental.0`
+                : '@hubspot/cli';
+            finalCommand = command.replace(/^hs /, `npx -y -p ${cliPackage} hs `);
+        }
         finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
     }
     return execAsync(finalCommand, {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.0",
+    "version": "8.0.1-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",