@hubspot/cli 8.0.0 → 8.0.2-experimental.0

package/lib/mcp/setup.js

@@ -179,38 +179,30 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
         try {
             // Check if claude command is available
             await execAsync('claude --version');
-            // Run claude mcp add command
-            const mcpConfig = JSON.stringify({
-                type: 'stdio',
-                ...buildCommandWithAgentString(mcpCommand, claudeCode),
-            });
-            const { stdout } = await execAsync('claude mcp list');
-            if (stdout.includes(mcpServerName)) {
-                SpinniesManager.update('claudeCode', {
-                    text: commands.mcp.setup.spinners.alreadyInstalled,
-                });
-                await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
-            }
-            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
-            SpinniesManager.succeed('claudeCode', {
-                text: commands.mcp.setup.spinners.configuredClaudeCode,
-            });
-            return true;
         }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('claude')) {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeNotFound,
-                });
-            }
-            else {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
-                });
-                logError(error);
-            }
+        catch (e) {
+            SpinniesManager.fail('claudeCode', {
+                text: commands.mcp.setup.spinners.claudeCodeNotFound,
+            });
             return false;
         }
+        // Run claude mcp add command
+        const mcpConfig = JSON.stringify({
+            type: 'stdio',
+            ...buildCommandWithAgentString(mcpCommand, claudeCode),
+        });
+        const { stdout } = await execAsync('claude mcp list');
+        if (stdout.includes(mcpServerName)) {
+            SpinniesManager.update('claudeCode', {
+                text: commands.mcp.setup.spinners.alreadyInstalled,
+            });
+            await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
+        }
+        await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
+        SpinniesManager.succeed('claudeCode', {
+            text: commands.mcp.setup.spinners.configuredClaudeCode,
+        });
+        return true;
     }
     catch (error) {
         SpinniesManager.fail('claudeCode', {
@@ -245,8 +237,16 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('codexSpinner', {
             text: commands.mcp.setup.spinners.configuringCodex,
         });
-        // Check if codex command is available
-        await execAsync('codex --version');
+        try {
+            // Check if codex command is available
+            await execAsync('codex --version');
+        }
+        catch (error) {
+            SpinniesManager.fail('codexSpinner', {
+                text: commands.mcp.setup.spinners.codexNotFound,
+            });
+            return false;
+        }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, codex);
         await execAsync(`codex mcp add "${mcpServerName}" -- ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('codexSpinner', {
@@ -255,17 +255,10 @@ export async function setupCodex(mcpCommand = defaultMcpCommand) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('codex')) {
-            SpinniesManager.fail('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('codexSpinner', {
-                text: commands.mcp.setup.spinners.codexInstallFailed,
-            });
-            logError(error);
-        }
+        SpinniesManager.fail('codexSpinner', {
+            text: commands.mcp.setup.spinners.codexInstallFailed,
+        });
+        logError(error);
         return false;
     }
 }
@@ -274,7 +267,15 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         SpinniesManager.add('geminiSpinner', {
             text: commands.mcp.setup.spinners.configuringGemini,
         });
-        await execAsync('gemini --version');
+        try {
+            await execAsync('gemini --version');
+        }
+        catch (e) {
+            SpinniesManager.fail('geminiSpinner', {
+                text: commands.mcp.setup.spinners.geminiNotFound,
+            });
+            return false;
+        }
         const mcpCommandWithAgent = buildCommandWithAgentString(mcpCommand, gemini);
         await execAsync(`gemini mcp add -s user "${mcpServerName}" ${mcpCommandWithAgent.command} ${mcpCommandWithAgent.args.join(' ')}`);
         SpinniesManager.succeed('geminiSpinner', {
@@ -283,17 +284,10 @@ export async function setupGemini(mcpCommand = defaultMcpCommand) {
         return true;
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('gemini')) {
-            SpinniesManager.fail('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('geminiSpinner', {
-                text: commands.mcp.setup.spinners.geminiInstallFailed,
-            });
-            logError(error);
-        }
+        SpinniesManager.fail('geminiSpinner', {
+            text: commands.mcp.setup.spinners.geminiInstallFailed,
+        });
+        logError(error);
         return false;
     }
 }

package/lib/projects/__tests__/LocalDevWebsocketServer.test.js

@@ -1,9 +1,7 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { uiLogger } from '../../ui/logger.js';
 import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
-import { lib } from '../../../lang/en.js';
 vi.mock('ws');
 vi.mock('@hubspot/local-dev-lib/portManager');
 describe('LocalDevWebsocketServer', () => {
@@ -12,19 +10,15 @@ describe('LocalDevWebsocketServer', () => {
     let mockWebSocketServer;
     let server;
     beforeEach(() => {
-        // Reset all mocks
-        // Setup mock WebSocket
         mockWebSocket = {
             on: vi.fn(),
             send: vi.fn(),
             close: vi.fn(),
         };
-        // Setup mock WebSocketServer
         mockWebSocketServer = {
             on: vi.fn(),
             close: vi.fn(),
         };
-        // Setup mock LocalDevProcess
         mockLocalDevProcess = {
             addStateListener: vi.fn(),
             removeStateListener: vi.fn(),
@@ -39,116 +33,47 @@ describe('LocalDevWebsocketServer', () => {
             targetProjectAccountId: 456,
             targetTestingAccountId: 789,
         };
-        // Mock WebSocketServer constructor
         WebSocketServer.mockImplementation(() => mockWebSocketServer);
-        // Create server instance
         server = new LocalDevWebsocketServer(mockLocalDevProcess, true);
     });
-    describe('start()', () => {
-        it('should throw error if port manager is not running', async () => {
-            isPortManagerServerRunning.mockResolvedValue(false);
-            await expect(server.start()).rejects.toThrow();
+    function startServerAndConnect(ws) {
+        const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
+        connectionCallback(ws ?? mockWebSocket, {
+            headers: { origin: 'https://app.hubspot.com' },
         });
-        it('should start websocket server successfully', async () => {
+    }
+    describe('start()', () => {
+        beforeEach(async () => {
             isPortManagerServerRunning.mockResolvedValue(true);
             requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
-            expect(WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
-            expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
-            expect(uiLogger.log).toHaveBeenCalled();
         });
-        describe('valid origins', () => {
-            const validOrigins = [
-                'https://app.hubspot.com',
-                'https://app.hubspotqa.com',
-                'https://local.hubspot.com',
-                'https://local.hubspotqa.com',
-                'https://app-na2.hubspot.com',
-                'https://app-na2.hubspotqa.com',
-                'https://app-na3.hubspot.com',
-                'https://app-na3.hubspotqa.com',
-                'https://app-ap1.hubspot.com',
-                'https://app-ap1.hubspotqa.com',
-                'https://app-eu1.hubspot.com',
-                'https://app-eu1.hubspotqa.com',
-            ];
-            validOrigins.forEach(origin => {
-                it(`should accept connection from ${origin}`, async () => {
-                    isPortManagerServerRunning.mockResolvedValue(true);
-                    requestPorts.mockResolvedValue({
-                        'local-dev-ui-websocket-server': 1234,
-                    });
-                    await server.start();
-                    // Get the connection callback
-                    const connectionCallback = mockWebSocketServer.on.mock
-                        .calls[0][1];
-                    // Simulate connection from valid origin
-                    connectionCallback(mockWebSocket, {
-                        headers: { origin },
-                    });
-                    expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
-                    expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
-                    expect(mockWebSocket.close).not.toHaveBeenCalled();
-                });
-            });
-        });
-        describe('invalid origins', () => {
-            const invalidOrigins = [
-                'https://malicious-site.com',
-                'https://app.malicious-site.com',
-                'https://app.hubspot.com.evil.com',
-            ];
-            invalidOrigins.forEach(origin => {
-                it(`should reject connection from "${origin}"`, async () => {
-                    isPortManagerServerRunning.mockResolvedValue(true);
-                    requestPorts.mockResolvedValue({
-                        'local-dev-ui-websocket-server': 1234,
-                    });
-                    await server.start();
-                    // Get the connection callback
-                    const connectionCallback = mockWebSocketServer.on.mock
-                        .calls[0][1];
-                    // Simulate connection from invalid origin
-                    connectionCallback(mockWebSocket, {
-                        headers: { origin },
-                    });
-                    expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed(origin));
-                    expect(mockWebSocket.on).not.toHaveBeenCalled();
-                    expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
-                });
-            });
+        it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', () => {
+            startServerAndConnect();
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
-        it('should reject connection with no origin header', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-            // Get the connection callback
-            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-            // Simulate connection with no origin header
-            connectionCallback(mockWebSocket, {
-                headers: {},
-            });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed());
-            expect(mockWebSocket.on).not.toHaveBeenCalled();
-            expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
+        it('should send project data on connection', () => {
+            startServerAndConnect();
+            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
+                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
+                data: {
+                    projectName: 'test-project',
+                    projectId: 123,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+                    targetProjectAccountId: 456,
+                    targetTestingAccountId: 789,
+                },
+            }));
         });
-        it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-            // Get the connection callback
-            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-            // Simulate connection from valid origin
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app-na3.hubspot.com' },
-            });
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+        it('should setup state listeners on connection', () => {
+            startServerAndConnect();
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('appData', expect.any(Function));
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('uploadWarnings', expect.any(Function));
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('devServersStarted', expect.any(Function));
         });
     });
     describe('message handling', () => {
@@ -158,39 +83,13 @@ describe('LocalDevWebsocketServer', () => {
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
-            const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-            connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
+            startServerAndConnect();
         });
         it('should handle UPLOAD message type', () => {
-            const messageCallback = mockWebSocket.on.mock.calls[0][1];
-            const message = {
-                type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
-            };
-            messageCallback(JSON.stringify(message));
+            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
+            messageCallback(JSON.stringify({ type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD }));
             expect(mockLocalDevProcess.uploadProject).toHaveBeenCalled();
         });
-        it('should log error for missing message type', () => {
-            const messageCallback = mockWebSocket.on.mock.calls[0][1];
-            const message = {};
-            messageCallback(JSON.stringify(message));
-            expect(uiLogger.error).toHaveBeenCalled();
-        });
-        it('should log error for unknown message type', () => {
-            const messageCallback = mockWebSocket.on.mock.calls[0][1];
-            const message = {
-                type: 'UNKNOWN_TYPE',
-            };
-            messageCallback(JSON.stringify(message));
-            expect(uiLogger.error).toHaveBeenCalled();
-        });
-        it('should log error for invalid JSON', () => {
-            const messageCallback = mockWebSocket.on.mock.calls[0][1];
-            const invalidJson = 'invalid json';
-            messageCallback(invalidJson);
-            expect(uiLogger.error).toHaveBeenCalled();
-        });
     });
     describe('shutdown()', () => {
         it('should close the websocket server', async () => {
@@ -209,7 +108,6 @@ describe('LocalDevWebsocketServer', () => {
         let mockWebSocket3;
         let connectionCallback;
         beforeEach(async () => {
-            // Setup multiple mock WebSockets
             mockWebSocket1 = {
                 on: vi.fn(),
                 send: vi.fn(),
@@ -225,17 +123,14 @@ describe('LocalDevWebsocketServer', () => {
                 send: vi.fn(),
                 close: vi.fn(),
             };
-            // Start the server
             isPortManagerServerRunning.mockResolvedValue(true);
             requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
-            // Get the connection callback
             connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
         });
         it('should handle multiple valid connections simultaneously', () => {
-            // Establish three connections from valid origins
             connectionCallback(mockWebSocket1, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
@@ -245,30 +140,24 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket3, {
                 headers: { origin: 'https://local.hubspot.com' },
             });
-            // All connections should be established with proper setup
             expect(mockWebSocket1.on).toHaveBeenCalledWith('message', expect.any(Function));
             expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
             expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
-            // Each connection should trigger state listener setup
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(12); // 4 listeners per connection * 3 connections
-            // Each connection should trigger dev server message
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(12);
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
-            // No connections should be closed
             expect(mockWebSocket1.close).not.toHaveBeenCalled();
             expect(mockWebSocket2.close).not.toHaveBeenCalled();
             expect(mockWebSocket3.close).not.toHaveBeenCalled();
         });
         it('should send project data to each connection independently', () => {
-            // Establish multiple connections
             connectionCallback(mockWebSocket1, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
                 headers: { origin: 'https://app-eu1.hubspotqa.com' },
             });
-            // Each websocket should receive project data
-            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
+            const expectedProjectData = JSON.stringify({
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
                 data: {
                     projectName: 'test-project',
@@ -278,59 +167,41 @@ describe('LocalDevWebsocketServer', () => {
                     targetProjectAccountId: 456,
                     targetTestingAccountId: 789,
                 },
-            }));
-            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
-                data: {
-                    projectName: 'test-project',
-                    projectId: 123,
-                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
-                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
-                    targetProjectAccountId: 456,
-                    targetTestingAccountId: 789,
-                },
-            }));
+            });
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(expectedProjectData);
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(expectedProjectData);
         });
         it('should properly cleanup listeners when connections close', () => {
-            // Establish connections
             connectionCallback(mockWebSocket1, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
                 headers: { origin: 'https://app-ap1.hubspotqa.com' },
             });
-            // Get all the close callbacks for both connections (there should be 2 per connection)
             const closeCallbacks1 = mockWebSocket1.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(4); // projectNodes, appData, devServersStarted, and uploadWarnings listeners
-            expect(closeCallbacks2).toHaveLength(4); // projectNodes, appData, devServersStarted, and uploadWarnings listeners
-            // Simulate first connection closing (call all close callbacks)
+            expect(closeCallbacks1).toHaveLength(4);
+            expect(closeCallbacks2).toHaveLength(4);
             closeCallbacks1.forEach(callback => callback());
-            // Should have removed listeners for first connection (4 listeners: projectNodes, appData, devServersStarted, and uploadWarnings)
             expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
-            // Simulate second connection closing
             closeCallbacks2.forEach(callback => callback());
-            // Should have removed listeners for second connection as well
             expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(8);
         });
         it('should broadcast state changes to all connected clients', () => {
-            // Establish connections
             connectionCallback(mockWebSocket1, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
                 headers: { origin: 'https://local.hubspotqa.com' },
             });
-            // Get the projectNodes listeners that were registered
             const projectNodesListeners = mockLocalDevProcess.addStateListener.mock.calls
                 .filter(call => call[0] === 'projectNodes')
                 .map(call => call[1]);
             expect(projectNodesListeners).toHaveLength(2);
-            // Simulate a project nodes update by calling the listeners
             const mockProjectNodes = {
                 component1: {
                     uid: 'component1',
@@ -349,15 +220,12 @@ describe('LocalDevWebsocketServer', () => {
                 },
             };
             projectNodesListeners.forEach(listener => listener(mockProjectNodes));
-            // Both websockets should receive the update
-            expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
-                data: mockProjectNodes,
-            }));
-            expect(mockWebSocket2.send).toHaveBeenCalledWith(JSON.stringify({
+            const expectedMessage = JSON.stringify({
                 type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
                 data: mockProjectNodes,
-            }));
+            });
+            expect(mockWebSocket1.send).toHaveBeenCalledWith(expectedMessage);
+            expect(mockWebSocket2.send).toHaveBeenCalledWith(expectedMessage);
         });
     });
 });

package/lib/projects/localDev/LocalDevWebsocketServer.d.ts

@@ -1,19 +1,14 @@
 import LocalDevProcess from './LocalDevProcess.js';
 declare class LocalDevWebsocketServer {
-    private server?;
-    private debug?;
+    private cliWebSocketServer;
     private localDevProcess;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
-    private log;
-    private logError;
-    private sendMessage;
     private handleUpload;
     private handleDeploy;
     private handleAppInstallSuccess;
     private handleAppInstallFailure;
     private handleAppInstallInitiated;
-    private setupMessageHandlers;
-    private sendCliMetadata;
+    private handleMessage;
     private sendProjectData;
     private setupProjectNodesListener;
     private setupAppDataListener;