@hubspot/cli 7.8.12-experimental.1 → 7.9.0-beta.0

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

@@ -12,8 +12,6 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
 import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
-import { requestPorts } from '@hubspot/local-dev-lib/portManager';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import AppDevModeInterface from '../localDev/AppDevModeInterface.js';
 import LocalDevState from '../localDev/LocalDevState.js';
@@ -129,7 +127,16 @@ describe('AppDevModeInterface', () => {
         getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
         getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
         installAppAutoPrompt.mockResolvedValue(true);
-        installAppBrowserPrompt.mockResolvedValue(undefined);
+        installAppBrowserPrompt.mockImplementation(async () => {
+            setTimeout(() => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+            }, 0);
+            return undefined;
+        });
         confirmPrompt.mockResolvedValue(true);
         installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
         // Mock process.exit
@@ -190,16 +197,14 @@ describe('AppDevModeInterface', () => {
         });
         it('should return early if no app node exists', async () => {
             mockLocalDevState.projectNodes = {};
-            await appDevModeInterface.setup({});
+            await appDevModeInterface.setup();
             expect(fetchAppMetadataByUid).not.toHaveBeenCalled();
-            expect(UIEDevModeInterface.setup).not.toHaveBeenCalled();
         });
         it('should setup successfully with private app', async () => {
-            await appDevModeInterface.setup({});
+            await appDevModeInterface.setup();
             expect(fetchAppMetadataByUid).toHaveBeenCalledWith('test-app-uid', 12345);
             expect(fetchPublicAppProductionInstallCounts).toHaveBeenCalledWith(123, 12345);
             expect(fetchAppInstallationData).toHaveBeenCalledWith(67890, 999, 'test-app-uid', ['test-scope'], []);
-            expect(UIEDevModeInterface.setup).toHaveBeenCalled();
         });
         it('should show marketplace warning for marketplace apps', async () => {
             const marketplaceAppNode = {
@@ -212,7 +217,7 @@ describe('AppDevModeInterface', () => {
             mockLocalDevState.projectNodes = {
                 [marketplaceAppNode.uid]: marketplaceAppNode,
             };
-            await appDevModeInterface.setup({});
+            await appDevModeInterface.setup();
             expect(confirmPrompt).toHaveBeenCalled();
             expect(mockLocalDevState.addUploadWarning).toHaveBeenCalled();
         });
@@ -239,24 +244,19 @@ describe('AppDevModeInterface', () => {
                 localDevLogger: mockLocalDevLogger,
             });
             // The setup method catches the error, so we check that process.exit was called
-            await newAppDevModeInterface.setup({});
+            await newAppDevModeInterface.setup();
             expect(process.exit).toHaveBeenCalledWith(0);
         });
-        // @TODO: Restore test account auto install functionality
-        // it('should auto-install static auth app on test account', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   await appDevModeInterface.setup({});
-        //   expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(
-        //     123,
-        //     67890,
-        //     [1, 2, 3]
-        //   );
-        // });
+        it('should auto-install static auth app on test account', async () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            await appDevModeInterface.setup();
+            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
+        });
         it('should open browser for OAuth app installation', async () => {
             const oauthAppNode = {
                 ...mockAppNode,
@@ -275,7 +275,7 @@ describe('AppDevModeInterface', () => {
                     previouslyAuthorizedScopeGroups: [],
                 },
             });
-            await appDevModeInterface.setup({});
+            await appDevModeInterface.setup();
             expect(getOauthAppInstallUrl).toHaveBeenCalledWith({
                 targetAccountId: 67890,
                 env: ENVIRONMENTS.PROD,
@@ -294,97 +294,58 @@ describe('AppDevModeInterface', () => {
                     previouslyAuthorizedScopeGroups: ['old-scope'],
                 },
             });
-            await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true, {
-                appUid: 'test-app-uid',
-                projectAccountId: 12345,
-                projectName: 'test-project',
-                testingAccountId: 67890,
-            });
+            await appDevModeInterface.setup();
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
             fetchAppMetadataByUid.mockRejectedValue(error);
-            await appDevModeInterface.setup({});
+            await appDevModeInterface.setup();
             expect(logError).toHaveBeenCalledWith(error);
         });
-        // @TODO: Restore test account auto install functionality
-        // it('should exit if user declines auto-install', async () => {
-        //   // Set up conditions for automatic installation
-        //   (getAccountConfig as Mock).mockReturnValue({
-        //     parentAccountId: 12345, // matches targetProjectAccountId
-        //   });
-        //   (isDeveloperTestAccount as Mock).mockReturnValue(true);
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installAppAutoPrompt as Mock).mockResolvedValue(false);
-        //   // Create a new instance to trigger the exit during setup
-        //   const newAppDevModeInterface = new AppDevModeInterface({
-        //     localDevState: mockLocalDevState,
-        //     localDevLogger: mockLocalDevLogger,
-        //   });
-        //   // The setup method catches the error, so we check that process.exit was called
-        //   await newAppDevModeInterface.setup({});
-        //   expect(process.exit).toHaveBeenCalledWith(0);
-        // });
-        // @TODO: Restore test account auto install functionality
-        // it('should fallback to browser install if auto-install fails', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installStaticAuthAppOnTestAccount as Mock).mockRejectedValue(
-        //     new Error('Install failed')
-        //   );
-        //   await appDevModeInterface.setup({});
-        //   expect(installAppBrowserPrompt).toHaveBeenCalledWith(
-        //     'http://static-install-url',
-        //     false
-        //   );
-        // });
-    });
-    describe('start()', () => {
-        it('should return early if no app node exists', async () => {
-            mockLocalDevState.projectNodes = {};
-            await appDevModeInterface.start();
-            expect(UIEDevModeInterface.start).not.toHaveBeenCalled();
+        it('should exit if user declines auto-install', async () => {
+            // Set up conditions for automatic installation
+            getAccountConfig.mockReturnValue({
+                parentAccountId: 12345, // matches targetProjectAccountId
+            });
+            isDeveloperTestAccount.mockReturnValue(true);
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            installAppAutoPrompt.mockResolvedValue(false);
+            // Create a new instance to trigger the exit during setup
+            const newAppDevModeInterface = new AppDevModeInterface({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
+            // The setup method catches the error, so we check that process.exit was called
+            await newAppDevModeInterface.setup();
+            expect(process.exit).toHaveBeenCalledWith(0);
         });
-        it('should start UIE dev mode interface', async () => {
-            await appDevModeInterface.start();
-            expect(UIEDevModeInterface.start).toHaveBeenCalledWith({
-                accountId: 67890,
-                projectConfig: mockProjectConfig,
-                requestPorts,
+        it('should fallback to browser install if auto-install fails', async () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
             });
+            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
+            await appDevModeInterface.setup();
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
         });
     });
-    describe('fileChange()', () => {
-        it('should return early if no app node exists', async () => {
-            mockLocalDevState.projectNodes = {};
-            await appDevModeInterface.fileChange('test.js', 'change');
-            expect(UIEDevModeInterface.fileChange).not.toHaveBeenCalled();
-        });
-        it('should forward file change to UIE dev mode interface', async () => {
-            await appDevModeInterface.fileChange('test.js', 'change');
-            expect(UIEDevModeInterface.fileChange).toHaveBeenCalledWith('test.js', 'change');
+    describe('start()', () => {
+        it('should add state listeners', async () => {
+            await appDevModeInterface.start();
+            expect(mockLocalDevState.addListener).toHaveBeenCalledWith('projectNodes', 
+            // @ts-expect-error access private method for testing
+            appDevModeInterface.onChangeProjectNodes);
         });
     });
     describe('cleanup()', () => {
-        it('should return early if no app node exists', async () => {
-            mockLocalDevState.projectNodes = {};
-            await appDevModeInterface.cleanup();
-            expect(UIEDevModeInterface.cleanup).not.toHaveBeenCalled();
-        });
-        it('should cleanup UIE dev mode interface', async () => {
-            await appDevModeInterface.cleanup();
-            expect(UIEDevModeInterface.cleanup).toHaveBeenCalled();
-        });
         it('should remove state listeners', async () => {
             await appDevModeInterface.cleanup();
             expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('devServerMessage', 
@@ -411,7 +372,14 @@ describe('AppDevModeInterface', () => {
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -430,7 +398,7 @@ describe('AppDevModeInterface', () => {
                 localDevState: mockLocalDevState,
                 localDevLogger: mockLocalDevLogger,
             });
-            await newAppDevModeInterface.setup({});
+            await newAppDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalled();
         });
         it('should return false for OAuth app', async () => {
@@ -444,7 +412,16 @@ describe('AppDevModeInterface', () => {
                 data: { uniquePortalInstallCount: 5 },
             });
             getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -472,7 +449,7 @@ describe('AppDevModeInterface', () => {
                 localDevState: mockLocalDevState,
                 localDevLogger: mockLocalDevLogger,
             });
-            await newAppDevModeInterface.setup({});
+            await newAppDevModeInterface.setup();
             expect(installAppBrowserPrompt).toHaveBeenCalled();
         });
     });
@@ -488,7 +465,16 @@ describe('AppDevModeInterface', () => {
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -505,7 +491,7 @@ describe('AppDevModeInterface', () => {
                 localDevState: mockLocalDevState,
                 localDevLogger: mockLocalDevLogger,
             });
-            await newAppDevModeInterface.setup({});
+            await newAppDevModeInterface.setup();
             // Simulate websocket server connection
             const addListenerCall = mockLocalDevState.addListener.mock
                 .calls[0];

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

@@ -0,0 +1,183 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import DevServerManager from '../localDev/DevServerManager.js';
+import LocalDevState from '../localDev/LocalDevState.js';
+import LocalDevLogger from '../localDev/LocalDevLogger.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+    DevModeUnifiedInterface: {
+        setup: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        fileChange: vi.fn().mockResolvedValue(undefined),
+        cleanup: vi.fn().mockResolvedValue(undefined),
+    },
+}));
+vi.mock('@hubspot/local-dev-lib/portManager', () => ({
+    requestPorts: vi.fn().mockResolvedValue({ 'test-port': 8080 }),
+}));
+vi.mock('@hubspot/local-dev-lib/api/localDevAuth', () => ({
+    fetchAppInstallationData: vi.fn().mockResolvedValue({}),
+}));
+vi.mock('@hubspot/local-dev-lib/api/appsDev', () => ({
+    fetchAppMetadataByUid: vi.fn().mockResolvedValue({}),
+    fetchPublicAppProductionInstallCounts: vi.fn().mockResolvedValue({}),
+    installStaticAuthAppOnTestAccount: vi.fn().mockResolvedValue({}),
+}));
+vi.mock('@hubspot/local-dev-lib/config', () => ({
+    getAccountConfig: vi.fn().mockReturnValue({ accountId: 123 }),
+    configFileExists: vi.fn().mockReturnValue(true),
+    getAccountId: vi.fn().mockReturnValue(123),
+    hasLocalStateFlag: vi.fn().mockReturnValue(false),
+    getConfigDefaultAccount: vi.fn().mockReturnValue({ accountId: 123 }),
+}));
+vi.mock('@hubspot/local-dev-lib/urls', () => ({
+    getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),
+    getHubSpotWebsiteOrigin: vi.fn().mockReturnValue('https://app.hubspot.com'),
+}));
+vi.mock('../../ui/SpinniesManager', () => ({
+    default: {
+        add: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        init: vi.fn(),
+    },
+}));
+describe('DevServerManager', () => {
+    let devServerManager;
+    let localDevState;
+    let logger;
+    beforeEach(() => {
+        localDevState = new LocalDevState({
+            targetProjectAccountId: 123,
+            targetTestingAccountId: 456,
+            projectConfig: {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '1.0.0',
+            },
+            projectDir: '/test/project',
+            projectData: {
+                name: 'test-project',
+                id: 123,
+                createdAt: Date.now(),
+                deletedAt: 0,
+                isLocked: false,
+                portalId: 123,
+                updatedAt: Date.now(),
+            },
+            debug: false,
+            initialProjectNodes: {},
+            initialProjectProfileData: {},
+            profile: 'test',
+            env: ENVIRONMENTS.QA,
+        });
+        logger = new LocalDevLogger(localDevState);
+        devServerManager = new DevServerManager({
+            localDevState,
+            logger,
+        });
+    });
+    describe('constructor', () => {
+        it('should initialize with correct state', async () => {
+            await expect(async () => {
+                await devServerManager.start();
+            }).rejects.toThrow('The Dev Server Manager must be initialized before it is started.');
+        });
+    });
+    describe('setup', () => {
+        it('should complete setup without errors', async () => {
+            await expect(devServerManager.setup()).resolves.not.toThrow();
+        });
+        it('should allow start after successful setup', async () => {
+            await devServerManager.setup();
+            await expect(devServerManager.start()).resolves.not.toThrow();
+        });
+        it('should call setup on dev servers sequentially', async () => {
+            const executionOrder = [];
+            const { DevModeUnifiedInterface } = await import('@hubspot/ui-extensions-dev-server');
+            const originalSetup = DevModeUnifiedInterface.setup;
+            DevModeUnifiedInterface.setup = vi.fn().mockImplementation(async () => {
+                executionOrder.push('UIExtensions-start');
+                await new Promise(resolve => setTimeout(resolve, 20));
+                executionOrder.push('UIExtensions-end');
+            });
+            const AppDevModeInterface = (await import('../localDev/AppDevModeInterface.js')).default;
+            const originalAppSetup = AppDevModeInterface.prototype.setup;
+            AppDevModeInterface.prototype.setup = vi
+                .fn()
+                .mockImplementation(async function () {
+                executionOrder.push('App-start');
+                await new Promise(resolve => setTimeout(resolve, 20));
+                executionOrder.push('App-end');
+            });
+            const testManager = new DevServerManager({
+                localDevState,
+                logger,
+            });
+            await testManager.setup();
+            expect(executionOrder).toEqual([
+                'App-start',
+                'App-end',
+                'UIExtensions-start',
+                'UIExtensions-end',
+            ]);
+            expect(AppDevModeInterface.prototype.setup).toHaveBeenCalledTimes(1);
+            expect(DevModeUnifiedInterface.setup).toHaveBeenCalledTimes(1);
+            // Restore original methods
+            DevModeUnifiedInterface.setup = originalSetup;
+            AppDevModeInterface.prototype.setup = originalAppSetup;
+        });
+    });
+    describe('start', () => {
+        it('should throw error when not initialized', async () => {
+            await expect(devServerManager.start()).rejects.toThrow();
+        });
+        it('should start successfully after setup', async () => {
+            await devServerManager.setup();
+            await expect(devServerManager.start()).resolves.not.toThrow();
+        });
+        it('should set started state correctly', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.fileChange({ filePath: 'test.js', event: 'change' })).resolves.not.toThrow();
+        });
+    });
+    describe('fileChange', () => {
+        it('should handle fileChange', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.fileChange({
+                filePath: 'src/test.js',
+                event: 'change',
+            })).resolves.not.toThrow();
+        });
+        it('should handle different file events', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            const testCases = [
+                { filePath: 'src/component.js', event: 'add' },
+                { filePath: 'src/style.css', event: 'change' },
+                { filePath: 'src/config.json', event: 'unlink' },
+            ];
+            for (const testCase of testCases) {
+                await expect(devServerManager.fileChange(testCase)).resolves.not.toThrow();
+            }
+        });
+        it('should handle concurrent fileChange calls', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            const fileChanges = [
+                devServerManager.fileChange({ filePath: 'file1.js', event: 'change' }),
+                devServerManager.fileChange({ filePath: 'file2.js', event: 'add' }),
+                devServerManager.fileChange({ filePath: 'file3.js', event: 'unlink' }),
+            ];
+            await expect(Promise.all(fileChanges)).resolves.not.toThrow();
+        });
+    });
+    describe('cleanup', () => {
+        it('should handle cleanup', async () => {
+            await devServerManager.setup();
+            await devServerManager.start();
+            await expect(devServerManager.cleanup()).resolves.not.toThrow();
+        });
+    });
+});

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

@@ -7,7 +7,7 @@ import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import LocalDevProcess from '../localDev/LocalDevProcess.js';
 import LocalDevLogger from '../localDev/LocalDevLogger.js';
-import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
+import DevServerManager from '../localDev/DevServerManager.js';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { vi } from 'vitest';
 // Mock @hubspot/ui-extensions-dev-server
@@ -27,7 +27,7 @@ vi.mock('../config');
 vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('../localDev/LocalDevLogger');
-vi.mock('../localDev/DevServerManagerV2');
+vi.mock('../localDev/DevServerManager');
 // Tests for LocalDevProcess and LocalDevState
 describe('LocalDevProcess', () => {
     let mockLocalDevLogger;
@@ -67,6 +67,7 @@ describe('LocalDevProcess', () => {
                 subbuildStatuses: [],
                 uploadMessage: 'Build completed',
                 autoDeployId: 0,
+                platformVersion: '2025.2',
             },
         },
         initialProjectNodes: {},
@@ -104,7 +105,7 @@ describe('LocalDevProcess', () => {
         };
         // Mock constructors
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
-        DevServerManagerV2.mockImplementation(() => mockDevServerManager);
+        DevServerManager.mockImplementation(() => mockDevServerManager);
         // Mock external functions
         isHubSpotHttpError.mockReturnValue(false);
         // Create process instance
@@ -398,7 +399,7 @@ describe('LocalDevProcess', () => {
             expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
             'test-project', // projectName
             123, // buildId
-            true, // useV3Api
+            true, // useV2Api
             false // force
             );
             expect(mockLocalDevLogger.deploySuccess).toHaveBeenCalled();
@@ -426,7 +427,7 @@ describe('LocalDevProcess', () => {
             expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
             'test-project', // projectName
             123, // buildId
-            true, // useV3Api
+            true, // useV2Api
             true // force
             );
             expect(result).toEqual({

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

@@ -252,7 +252,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(9); // 3 listeners per connection * 3 connections
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(12); // 4 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);
@@ -308,16 +308,16 @@ describe('LocalDevWebsocketServer', () => {
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
-            expect(closeCallbacks2).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
+            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)
             closeCallbacks1.forEach(callback => callback());
-            // Should have removed listeners for first connection (3 listeners: projectNodes, appData, and uploadWarnings)
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
+            // 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(6);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(8);
         });
         it('should broadcast state changes to all connected clients', () => {
             // Establish connections

package/lib/projects/__tests__/UIExtensionsDevModeInterface.test.d.ts

@@ -0,0 +1 @@
+export {};