@hubspot/cli 7.7.27-experimental.2 → 7.7.29-experimental.0

package/lib/hasFeature.d.ts

@@ -1,3 +1,4 @@
 import { FEATURES } from './constants.js';
 import { ValueOf } from '@hubspot/local-dev-lib/types/Utils';
 export declare function hasFeature(accountId: number, feature: ValueOf<typeof FEATURES>): Promise<boolean>;
+export declare function hasUnfiedAppsAccess(accountId: number): Promise<boolean>;

package/lib/hasFeature.js

@@ -1,5 +1,12 @@
+import { http } from '@hubspot/local-dev-lib/http';
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
 export async function hasFeature(accountId, feature) {
     const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
     return Boolean(enabledFeatures[feature]);
 }
+export async function hasUnfiedAppsAccess(accountId) {
+    const response = await http.get(accountId, {
+        url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
+    });
+    return Boolean(response.data);
+}

package/lib/importData.d.ts

@@ -0,0 +1,3 @@
+import { ImportRequest } from '@hubspot/local-dev-lib/types/Crm';
+export declare function handleImportData(targetAccountId: number, dataFileNames: string[], importRequest: ImportRequest): Promise<void>;
+export declare function handleTargetTestAccountSelectionFlow(derivedAccountId: number, userProvidedAccount: string | number | undefined): Promise<number>;

package/lib/importData.js

@@ -0,0 +1,50 @@
+import { getAccountConfig, getAccountId, getEnv, } from '@hubspot/local-dev-lib/config';
+import { createImport } from '@hubspot/local-dev-lib/api/crm';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { importDataTestAccountSelectPrompt } from './prompts/importDataTestAccountSelectPrompt.js';
+import { lib } from '../lang/en.js';
+import { isAppDeveloperAccount, isDeveloperTestAccount, isStandardAccount, } from './accountTypes.js';
+import { uiLogger } from './ui/logger.js';
+export async function handleImportData(targetAccountId, dataFileNames, importRequest) {
+    try {
+        const baseUrl = getHubSpotWebsiteOrigin(getEnv());
+        const response = await createImport(targetAccountId, importRequest, dataFileNames);
+        const importId = response.data.id;
+        uiLogger.success(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
+    }
+    catch (error) {
+        uiLogger.error(lib.importData.errors.failedToImportData);
+        throw error;
+    }
+}
+export async function handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccount) {
+    let targetAccountId = null;
+    if (userProvidedAccount) {
+        targetAccountId = getAccountId(userProvidedAccount);
+    }
+    // Only allow users to pass in test accounts
+    if (targetAccountId) {
+        const testAccount = getAccountConfig(targetAccountId);
+        if (!testAccount || !isDeveloperTestAccount(testAccount)) {
+            throw new Error(lib.importData.errors.notDeveloperTestAccount);
+        }
+    }
+    else {
+        const targetProjectAccountConfig = getAccountConfig(derivedAccountId);
+        if (!targetProjectAccountConfig) {
+            throw new Error(lib.importData.errors.noAccountConfig(derivedAccountId));
+        }
+        if (isDeveloperTestAccount(targetProjectAccountConfig)) {
+            targetAccountId = derivedAccountId;
+        }
+        else if (!isStandardAccount(targetProjectAccountConfig) &&
+            !isAppDeveloperAccount(targetProjectAccountConfig)) {
+            throw new Error(lib.importData.errors.incorrectAccountType(derivedAccountId));
+        }
+        else {
+            const { selectedAccountId } = await importDataTestAccountSelectPrompt(derivedAccountId);
+            targetAccountId = selectedAccountId;
+        }
+    }
+    return targetAccountId;
+}

package/lib/mcp/setup.d.ts

@@ -15,11 +15,9 @@ interface McpCommand {
     command: string;
     args: string[];
 }
-export declare function addMintlifyMcpServer(installTargets: string[]): Promise<void>;
-export declare function setupMintlify(derivedTargets?: string[]): Promise<boolean>;
 export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
-export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
 export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
-export declare function setupCursor(mcpCommand?: McpCommand): boolean;
-export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupCursor(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupWindsurf(mcpCommand?: McpCommand): Promise<boolean>;
 export {};

package/lib/mcp/setup.js

@@ -4,17 +4,11 @@ import { promptUser } from '../prompts/promptUtils.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { logError } from '../errorHandlers/index.js';
 import { execAsync } from '../../mcp-server/utils/command.js';
-import { spawn } from 'node:child_process';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-import { existsSync } from 'fs';
 const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const vscode = 'vscode';
-const supportedMintlifyClients = [windsurf, cursor];
 export const supportedTools = [
     { name: commands.mcp.setup.claudeCode, value: claudeCode },
     { name: commands.mcp.setup.cursor, value: cursor },
@@ -25,28 +19,6 @@ const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMintlifyMcpServer(installTargets) {
-    await runSetupFunction(() => setupMintlify(installTargets));
-}
-export async function setupMintlify(derivedTargets = supportedMintlifyClients) {
-    uiLogger.info(commands.mcp.setup.installingDocSearch);
-    uiLogger.log('');
-    return new Promise(resolve => {
-        const subcommands = ['mint-mcp', 'add', 'hubspot-migration'];
-        const docsSearchClients = derivedTargets.filter(target => supportedMintlifyClients.includes(target));
-        const childProcess = spawn(`npx`, docsSearchClients && docsSearchClients.length
-            ? [...subcommands, '--client', ...docsSearchClients]
-            : subcommands, {
-            stdio: 'inherit',
-        });
-        childProcess.on('exit', code => {
-            if (code !== 0) {
-                resolve(false);
-            }
-            resolve(true);
-        });
-    });
-}
 export async function addMcpServerToConfig(targets) {
     try {
         let derivedTargets = [];
@@ -96,96 +68,6 @@ async function runSetupFunction(func) {
         throw new Error();
     }
 }
-function setupMcpConfigFile(config) {
-    try {
-        SpinniesManager.add('spinner', {
-            text: config.configuringMessage,
-        });
-        if (!existsSync(config.configPath)) {
-            fs.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
-        }
-        let mcpConfig = {};
-        let configContent;
-        try {
-            configContent = fs.readFileSync(config.configPath, 'utf8');
-        }
-        catch (error) {
-            SpinniesManager.fail('spinner', {
-                text: config.failedMessage,
-            });
-            logError(error);
-            return false;
-        }
-        try {
-            // In the event the file exists, but is empty, initialize it to and empty object
-            if (configContent.trim() === '') {
-                mcpConfig = {};
-            }
-            else {
-                mcpConfig = JSON.parse(configContent);
-            }
-        }
-        catch (error) {
-            SpinniesManager.fail('spinner', {
-                text: config.failedMessage,
-            });
-            uiLogger.error(commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
-            return false;
-        }
-        // Initialize mcpServers if it doesn't exist
-        if (!mcpConfig.mcpServers) {
-            mcpConfig.mcpServers = {};
-        }
-        // Add or update HubSpot CLI MCP server
-        mcpConfig.mcpServers[mcpServerName] = {
-            ...config.mcpCommand,
-        };
-        // Write the updated config
-        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
-        SpinniesManager.succeed('spinner', {
-            text: config.configuredMessage,
-        });
-        return true;
-    }
-    catch (error) {
-        SpinniesManager.fail('spinner', {
-            text: config.failedMessage,
-        });
-        logError(error);
-        return false;
-    }
-}
-export async function setupVsCode(mcpCommand = defaultMcpCommand) {
-    try {
-        SpinniesManager.add('vsCode', {
-            text: commands.mcp.setup.spinners.configuringVsCode,
-        });
-        const mcpConfig = JSON.stringify({
-            name: mcpServerName,
-            ...buildCommandWithAgentString(mcpCommand, vscode),
-        });
-        await execAsync(`code --add-mcp '${mcpConfig}'`);
-        SpinniesManager.succeed('vsCode', {
-            text: commands.mcp.setup.spinners.configuredVsCode,
-        });
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error &&
-            error.message.includes('code: command not found')) {
-            SpinniesManager.fail('vsCode', {
-                text: commands.mcp.setup.spinners.vsCodeNotFound,
-            });
-        }
-        else {
-            SpinniesManager.fail('vsCode', {
-                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
-            });
-            logError(error);
-        }
-        return false;
-    }
-}
 export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
         SpinniesManager.add('claudeCode', {
@@ -206,15 +88,14 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
                 });
                 await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --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: command not found')) {
+            if (error instanceof Error && error.message.includes('claude')) {
                 SpinniesManager.fail('claudeCode', {
                     text: commands.mcp.setup.spinners.claudeCodeNotFound,
                 });
@@ -236,25 +117,44 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
         return false;
     }
 }
-export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
-    return setupMcpConfigFile({
-        configPath: cursorConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringCursor,
-        configuredMessage: commands.mcp.setup.spinners.configuredCursor,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureCursor,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
-    });
+async function setupVsCodeBasedIntegration(commandName, configuringText, configuredText, notFoundText, failedText, mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add(commandName, {
+            text: configuringText,
+        });
+        const mcpConfig = JSON.stringify({
+            name: mcpServerName,
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
+        await execAsync(`${commandName} --add-mcp ${JSON.stringify(mcpConfig)}`);
+        SpinniesManager.succeed(commandName, {
+            text: configuredText,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes(commandName)) {
+            SpinniesManager.fail(commandName, {
+                text: notFoundText,
+            });
+        }
+        else {
+            SpinniesManager.fail(commandName, {
+                text: failedText,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
+export async function setupVsCode(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('code', commands.mcp.setup.spinners.configuringVsCode, commands.mcp.setup.spinners.configuredVsCode, commands.mcp.setup.spinners.vsCodeNotFound, commands.mcp.setup.spinners.failedToConfigureVsCode, mcpCommand);
+}
+export async function setupCursor(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('cursor', commands.mcp.setup.spinners.configuringCursor, commands.mcp.setup.spinners.configuredCursor, commands.mcp.setup.spinners.cursorNotFound, commands.mcp.setup.spinners.failedToConfigureCursor, mcpCommand);
 }
-export function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
-    return setupMcpConfigFile({
-        configPath: windsurfConfigPath,
-        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
-        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
-        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
-        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
-    });
+export async function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    return setupVsCodeBasedIntegration('windsurf', commands.mcp.setup.spinners.configuringWindsurf, commands.mcp.setup.spinners.configuredWindsurf, commands.mcp.setup.spinners.windsurfNotFound, commands.mcp.setup.spinners.failedToConfigureWindsurf, mcpCommand);
 }
 function buildCommandWithAgentString(mcpCommand, agent) {
     const mcpCommandCopy = structuredClone(mcpCommand);

package/lib/process.js

@@ -1,29 +1,40 @@
 import readline from 'readline';
 import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
 import { i18n } from './lang.js';
+import { logError } from './errorHandlers/index.js';
+const SIGHUP = 'SIGHUP';
+const uncaughtException = 'uncaughtException';
 export const TERMINATION_SIGNALS = [
     'beforeExit',
     'SIGINT', // Terminal trying to interrupt (Ctrl + C)
     'SIGUSR1', // Start Debugger User-defined signal 1
     'SIGUSR2', // User-defined signal 2
-    'uncaughtException',
+    uncaughtException,
     'SIGTERM', // Represents a graceful termination
-    'SIGHUP', // Parent terminal has been closed
+    SIGHUP, // Parent terminal has been closed
 ];
 export function handleExit(callback) {
     let exitInProgress = false;
     TERMINATION_SIGNALS.forEach(signal => {
         process.removeAllListeners(signal);
-        process.on(signal, async () => {
+        process.on(signal, async (...args) => {
             // Prevent duplicate exit handling
             if (!exitInProgress) {
                 exitInProgress = true;
-                const isSIGHUP = signal === 'SIGHUP';
+                const isSIGHUP = signal === SIGHUP;
                 // Prevent logs when terminal closes
                 if (isSIGHUP) {
                     setLogLevel(LOG_LEVEL.NONE);
                 }
                 logger.debug(i18n(`lib.process.exitDebug`, { signal }));
+                if (signal === uncaughtException && args && args.length > 0) {
+                    try {
+                        logError(args[0]);
+                    }
+                    catch (e) {
+                        logger.error(args[0]);
+                    }
+                }
                 await callback({ isSIGHUP });
             }
         });

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

@@ -37,6 +37,7 @@ vi.mock('../../ui/logger');
 vi.mock('../../errorHandlers/index');
 vi.mock('../localDev/LocalDevState');
 vi.mock('../localDev/LocalDevLogger');
+vi.mock('../../ui/SpinniesManager');
 describe('AppDevModeInterface', () => {
     let appDevModeInterface;
     let mockLocalDevState;
@@ -98,10 +99,9 @@ describe('AppDevModeInterface', () => {
             getAppDataByUid: vi.fn(),
             setAppDataForUid: vi.fn(),
             addListener: vi.fn(),
-        };
-        mockLocalDevLogger = {
             addUploadWarning: vi.fn(),
         };
+        mockLocalDevLogger = {};
         // Mock constructors
         LocalDevState.mockImplementation(() => mockLocalDevState);
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
@@ -211,7 +211,7 @@ describe('AppDevModeInterface', () => {
             };
             await appDevModeInterface.setup({});
             expect(confirmPrompt).toHaveBeenCalled();
-            expect(mockLocalDevLogger.addUploadWarning).toHaveBeenCalled();
+            expect(mockLocalDevState.addUploadWarning).toHaveBeenCalled();
         });
         it('should exit if user declines marketplace warning', async () => {
             const marketplaceAppNode = {

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

@@ -32,51 +32,14 @@ describe('LocalDevProcess', () => {
         srcDir: 'src',
         platformVersion: '1.0.0',
     };
-    const mockSubbuildStatus = {
-        buildName: 'component1',
-        buildType: 'APP',
-        errorMessage: '',
-        finishedAt: new Date().toISOString(),
-        rootPath: '/test/path',
-        startedAt: new Date().toISOString(),
-        status: 'SUCCESS',
-        id: '123',
-        standardError: null,
-        visible: true,
-    };
-    const mockBuild = {
-        activitySource: { type: 'HUBSPOT' },
-        projectName: 'test-project',
-        uploadMessage: 'test-upload-message',
-        autoDeployId: 123,
-        buildId: 123,
-        createdAt: new Date().toISOString(),
-        deployableState: 'DEPLOYED',
-        finishedAt: new Date().toISOString(),
-        startedAt: new Date().toISOString(),
-        status: 'SUCCESS',
-        subbuildStatuses: [
-            { ...mockSubbuildStatus, buildName: 'component1' },
-            { ...mockSubbuildStatus, buildName: 'component2' },
-        ],
-        deployStatusTaskLocator: {
-            id: '123',
-            links: [],
-        },
-        enqueuedAt: new Date().toISOString(),
-        isAutoDeployEnabled: false,
-        portalId: 123,
-    };
     const mockOptions = {
         projectDir: '/test/project',
         projectConfig: mockProjectConfig,
         targetProjectAccountId: 123,
         targetTestingAccountId: 456,
         projectId: 789,
-        isGithubLinked: false,
         initialProjectNodes: {},
         env: ENVIRONMENTS.PROD,
-        deployedBuild: mockBuild,
         projectName: 'test-project',
     };
     beforeEach(() => {
@@ -87,7 +50,6 @@ describe('LocalDevProcess', () => {
             devServerStartError: vi.fn(),
             devServerCleanupError: vi.fn(),
             missingComponentsWarning: vi.fn(),
-            noDeployedBuild: vi.fn(),
             startupMessage: vi.fn(),
             monitorConsoleOutput: vi.fn(),
             cleanupStart: vi.fn(),
@@ -97,7 +59,6 @@ describe('LocalDevProcess', () => {
             projectConfigMismatch: vi.fn(),
             uploadError: vi.fn(),
             uploadSuccess: vi.fn(),
-            clearUploadWarnings: vi.fn(),
             fileChangeError: vi.fn(),
             uploadWarning: vi.fn(),
         };
@@ -118,14 +79,6 @@ describe('LocalDevProcess', () => {
         });
     });
     describe('start()', () => {
-        it('should exit if no deployed build exists', async () => {
-            const processWithoutBuild = new LocalDevProcess({
-                ...mockOptions,
-                deployedBuild: undefined,
-            });
-            await expect(processWithoutBuild.start()).rejects.toThrow('Process.exit called with code 0');
-            expect(mockLocalDevLogger.noDeployedBuild).toHaveBeenCalled();
-        });
         it('should exit if dev server setup fails', async () => {
             mockDevServerManager.setup.mockRejectedValue(new Error('Setup failed'));
             await expect(process.start()).rejects.toThrow('Process.exit called with code 1');
@@ -138,31 +91,6 @@ describe('LocalDevProcess', () => {
             expect(mockLocalDevLogger.monitorConsoleOutput).toHaveBeenCalled();
             expect(mockLocalDevLogger.missingComponentsWarning).not.toHaveBeenCalled();
         });
-        it('should warn about missing components', async () => {
-            const mockNode = {
-                uid: 'component3',
-                componentType: 'APP',
-                localDev: {
-                    componentRoot: '/test/path',
-                    componentConfigPath: '/test/path/config.json',
-                    configUpdatedSinceLastUpload: false,
-                },
-                componentDeps: {},
-                metaFilePath: '/test/path',
-                config: {},
-                files: [],
-            };
-            const processWithNode = new LocalDevProcess({
-                ...mockOptions,
-                initialProjectNodes: {
-                    component3: mockNode,
-                },
-            });
-            await processWithNode.start();
-            expect(mockLocalDevLogger.missingComponentsWarning).toHaveBeenCalledWith([
-                '[App] component3',
-            ]);
-        });
     });
     describe('stop()', () => {
         it('should exit with error if cleanup fails', async () => {
@@ -226,7 +154,8 @@ describe('LocalDevProcess', () => {
             });
             const success = await process.uploadProject();
             expect(mockLocalDevLogger.uploadSuccess).toHaveBeenCalled();
-            expect(mockLocalDevLogger.clearUploadWarnings).toHaveBeenCalled();
+            // @ts-expect-error accessing private property for testing
+            expect(process.state.uploadWarnings.size).toBe(0);
             expect(success).toBe(true);
         });
         it('should reset projectNodesAtLastUpload', async () => {
@@ -300,10 +229,10 @@ describe('LocalDevProcess', () => {
             process.state.projectNodes = {};
             expect(listener).toHaveBeenCalled();
         });
-        it('should call listener immediately when callOnInit is true', () => {
+        it('should call listener immediately', () => {
             const listener = vi.fn();
             const key = 'projectNodes';
-            process.addStateListener(key, listener, true);
+            process.addStateListener(key, listener);
             expect(listener).toHaveBeenCalledWith(process.projectNodes);
         });
     });
@@ -313,32 +242,13 @@ describe('LocalDevProcess', () => {
             const key = 'projectNodes';
             // Add the listener first
             process.addStateListener(key, listener);
-            // Trigger state change to verify listener is called
-            // @ts-expect-error
-            process.state.projectNodes = {};
             expect(listener).toHaveBeenCalledTimes(1);
             // Remove the listener
             process.removeStateListener(key, listener);
             // Trigger state change again to verify listener is no longer called
             // @ts-expect-error
             process.state.projectNodes = { newNode: { uid: 'newNode' } };
-            expect(listener).toHaveBeenCalledTimes(1); // Should still be 1, not 2
-        });
-        it('should not affect other listeners when removing one', () => {
-            const listener1 = vi.fn();
-            const listener2 = vi.fn();
-            const key = 'projectNodes';
-            // Add two listeners
-            process.addStateListener(key, listener1);
-            process.addStateListener(key, listener2);
-            // Remove only the first listener
-            process.removeStateListener(key, listener1);
-            // Trigger state change
-            // @ts-expect-error
-            process.state.projectNodes = {};
-            // Only listener2 should be called
-            expect(listener1).not.toHaveBeenCalled();
-            expect(listener2).toHaveBeenCalled();
+            expect(listener).toHaveBeenCalledTimes(1);
         });
     });
 });

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

@@ -66,7 +66,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function), true);
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
             expect(mockWebSocket.close).not.toHaveBeenCalled();
         });
         it('should reject connection from invalid origin', async () => {
@@ -215,7 +215,7 @@ describe('LocalDevWebsocketServer', () => {
             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(6); // 2 listeners per connection * 3 connections
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(9); // 3 listeners per connection * 3 connections
             // Each connection should trigger dev server message
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
@@ -284,16 +284,16 @@ describe('LocalDevWebsocketServer', () => {
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(2); // projectNodes and appData listeners
-            expect(closeCallbacks2).toHaveLength(2); // projectNodes and appData listeners
+            expect(closeCallbacks1).toHaveLength(3); // projectNodes and appData listeners
+            expect(closeCallbacks2).toHaveLength(3); // projectNodes and appData listeners
             // Simulate first connection closing (call all close callbacks)
             closeCallbacks1.forEach(callback => callback());
             // Should have removed listeners for first connection (2 listeners: projectNodes and appData)
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(2);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
             // Simulate second connection closing
             closeCallbacks2.forEach(callback => callback());
             // Should have removed listeners for second connection as well
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(6);
         });
         it('should broadcast state changes to all connected clients', () => {
             // Establish connections