@hubspot/cli 8.0.1-experimental.0 → 8.0.3-experimental.0

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/__tests__/ProjectLogsManager.test.js

@@ -2,6 +2,9 @@ import { ProjectLogsManager } from '../ProjectLogsManager.js';
 import { getProjectConfig } from '../config.js';
 import { ensureProjectExists } from '../ensureProjectExists.js';
 import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
+import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
+import { getDeployedProjectNodes } from '../localDev/helpers/project.js';
+import { isV2Project } from '../platformVersion.js';
 const SUBCOMPONENT_TYPES = {
     APP_ID: 'APP_ID',
     PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
@@ -17,11 +20,20 @@ const SUBCOMPONENT_TYPES = {
 vi.mock('../../projects/config');
 vi.mock('../../projects/ensureProjectExists');
 vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/api/appsDev');
+vi.mock('../../projects/localDev/helpers/project');
+vi.mock('../../projects/platformVersion');
 describe('lib/projects/ProjectLogsManager', () => {
     const accountId = 12345678;
     const appId = 999999;
     const projectName = 'super cool test project';
-    const projectConfig = { projectConfig: { name: projectName } };
+    const projectConfig = {
+        projectConfig: {
+            name: projectName,
+            srcDir: 'src',
+            platformVersion: '2024.1',
+        },
+    };
     const projectId = 987654321;
     const projectDetails = {
         project: {
@@ -33,16 +45,26 @@ describe('lib/projects/ProjectLogsManager', () => {
     };
     const function1 = {
         componentName: 'function1',
-        type: {
-            name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-        },
-        deployOutput: {
-            appId,
-            appFunctionName: 'function1',
-        },
+        appId,
     };
     const functions = [
         function1,
+        {
+            componentName: 'function2',
+            appId,
+        },
+    ];
+    const legacyApiFunctions = [
+        {
+            componentName: 'function1',
+            type: {
+                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
+            },
+            deployOutput: {
+                appId,
+                appFunctionName: 'function1',
+            },
+        },
         {
             componentName: 'function2',
             type: {
@@ -56,6 +78,7 @@ describe('lib/projects/ProjectLogsManager', () => {
     ];
     beforeEach(() => {
         ProjectLogsManager.reset();
+        isV2Project.mockReturnValue(false);
         getProjectConfig.mockResolvedValue(projectConfig);
         ensureProjectExists.mockResolvedValue(projectDetails);
         fetchProjectComponentsMetadata.mockResolvedValue({
@@ -69,7 +92,7 @@ describe('lib/projects/ProjectLogsManager', () => {
                             appId,
                         },
                         featureComponents: [
-                            ...functions,
+                            ...legacyApiFunctions,
                             {
                                 type: {
                                     name: 'NOT_AN_APP_FUNCTION',
@@ -128,6 +151,102 @@ describe('lib/projects/ProjectLogsManager', () => {
             expect(ProjectLogsManager.functions).toEqual(functions);
         });
     });
+    describe('v2 project init', () => {
+        const v2ProjectConfig = {
+            projectConfig: {
+                name: projectName,
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            },
+        };
+        const deployedBuildId = 555;
+        const v2ProjectDetails = {
+            project: {
+                id: projectId,
+                deployedBuild: {
+                    buildId: deployedBuildId,
+                    subbuildStatuses: {},
+                },
+            },
+        };
+        const appUid = 'my-app';
+        const fnUid1 = 'my-app/app.functions/function1';
+        const fnUid2 = 'my-app/app.functions/function2';
+        const deployedNodes = {
+            [appUid]: {
+                componentType: 'APPLICATION',
+                componentDeps: {},
+                metaFilePath: 'src/app/app-hsmeta.json',
+                uid: appUid,
+                config: {},
+                files: {},
+            },
+            [fnUid1]: {
+                componentType: 'APP_FUNCTION',
+                componentDeps: { app: appUid },
+                metaFilePath: 'src/app/app.functions/function1.functions/function-hsmeta.json',
+                uid: fnUid1,
+                config: { endpoint: { path: '/my-endpoint' } },
+                files: {},
+            },
+            [fnUid2]: {
+                componentType: 'APP_FUNCTION',
+                componentDeps: { app: appUid },
+                metaFilePath: 'src/app/app.functions/function2.functions/function-hsmeta.json',
+                uid: fnUid2,
+                config: {},
+                files: {},
+            },
+        };
+        beforeEach(() => {
+            getProjectConfig.mockResolvedValue(v2ProjectConfig);
+            ensureProjectExists.mockResolvedValue(v2ProjectDetails);
+            isV2Project.mockReturnValue(true);
+            getDeployedProjectNodes.mockResolvedValue(deployedNodes);
+            fetchAppMetadataBySourceId.mockResolvedValue({
+                data: { id: appId },
+            });
+        });
+        it('should populate functions correctly for v2 projects', async () => {
+            await ProjectLogsManager.init(accountId);
+            expect(getDeployedProjectNodes).toHaveBeenCalledWith(v2ProjectConfig.projectConfig, accountId, deployedBuildId);
+            expect(fetchAppMetadataBySourceId).toHaveBeenCalledWith(projectId, appUid, accountId);
+            expect(ProjectLogsManager.functions).toEqual([
+                {
+                    componentName: fnUid1,
+                    appId,
+                    endpoint: { path: '/my-endpoint' },
+                },
+                {
+                    componentName: fnUid2,
+                    appId,
+                    endpoint: undefined,
+                },
+            ]);
+        });
+        it('should throw noDeployedBuild when buildId is missing', async () => {
+            ensureProjectExists.mockResolvedValue({
+                project: {
+                    id: projectId,
+                    deployedBuild: {
+                        buildId: undefined,
+                        subbuildStatuses: {},
+                    },
+                },
+            });
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('This project has not been deployed yet. Deploy the project first, then try again.');
+        });
+        it('should throw noFunctionsInProject when no function nodes exist', async () => {
+            getDeployedProjectNodes.mockResolvedValue({
+                [appUid]: deployedNodes[appUid],
+            });
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There aren't any functions in this project/);
+        });
+        it('should throw a user-friendly error when getDeployedProjectNodes fails', async () => {
+            getDeployedProjectNodes.mockRejectedValue(new Error('download failed'));
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+        });
+    });
     describe('getFunctionNames', () => {
         it('should return an empty array if functions is empty', async () => {
             ProjectLogsManager.functions = [];
@@ -154,14 +273,8 @@ describe('lib/projects/ProjectLogsManager', () => {
         it('should set the data correctly for public functions', async () => {
             const functionToChoose = {
                 componentName: 'function1',
-                type: {
-                    name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-                },
-                deployOutput: {
-                    appId: 123,
-                    appFunctionName: 'function1',
-                    endpoint: { path: 'yooooooo', methods: ['GET'] },
-                },
+                appId: 123,
+                endpoint: { path: 'yooooooo' },
             };
             ProjectLogsManager.functions = [functionToChoose];
             ProjectLogsManager.setFunction('function1');
@@ -170,7 +283,7 @@ describe('lib/projects/ProjectLogsManager', () => {
             expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
             expect(ProjectLogsManager.isPublicFunction).toEqual(true);
         });
-        it('should set the data correctly for public functions', async () => {
+        it('should set the data correctly for private functions', async () => {
             ProjectLogsManager.functions = functions;
             ProjectLogsManager.setFunction('function1');
             expect(ProjectLogsManager.selectedFunction).toEqual(function1);

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

@@ -1,4 +1,4 @@
-import { isV2Project } from '../platformVersion.js';
+import { isV2Project, isUnsupportedPlatformVersion, } from '../platformVersion.js';
 describe('platformVersion', () => {
     describe('isV2Project', () => {
         it('returns true if platform version is UNSTABLE', () => {
@@ -24,4 +24,40 @@ describe('platformVersion', () => {
             expect(isV2Project('notplaformversion')).toBe(false);
         });
     });
+    describe('isUnsupportedPlatformVersion', () => {
+        it('returns false for platform version 2026.03 (boundary)', () => {
+            expect(isUnsupportedPlatformVersion('2026.03')).toBe(false);
+        });
+        it('returns false for platform versions less than 2026.03', () => {
+            expect(isUnsupportedPlatformVersion('2025.2')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.01')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.02')).toBe(false);
+        });
+        it('returns true for platform version 2026.04', () => {
+            expect(isUnsupportedPlatformVersion('2026.04')).toBe(true);
+        });
+        it('returns true for platform versions greater than 2026.03', () => {
+            expect(isUnsupportedPlatformVersion('2026.4')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.01')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.1')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2028.10')).toBe(true);
+        });
+        it('returns false for UNSTABLE', () => {
+            expect(isUnsupportedPlatformVersion('UNSTABLE')).toBe(false);
+            expect(isUnsupportedPlatformVersion('unstable')).toBe(false);
+        });
+        it('returns false for null or undefined', () => {
+            expect(isUnsupportedPlatformVersion(null)).toBe(false);
+            expect(isUnsupportedPlatformVersion(undefined)).toBe(false);
+        });
+        it('returns false for invalid platform versions', () => {
+            expect(isUnsupportedPlatformVersion('notaversion')).toBe(false);
+            expect(isUnsupportedPlatformVersion('abc.def')).toBe(false);
+        });
+        it('handles beta versions correctly', () => {
+            expect(isUnsupportedPlatformVersion('2026.03-beta')).toBe(false);
+            expect(isUnsupportedPlatformVersion('2026.04-beta')).toBe(true);
+            expect(isUnsupportedPlatformVersion('2027.01-beta')).toBe(true);
+        });
+    });
 });

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

@@ -16,12 +16,16 @@ describe('lib/projects', () => {
         });
         it('rejects configuration with missing name', () => {
             // @ts-ignore Testing invalid input
-            expect(() => validateProjectConfig({ srcDir: '.' }, projectDir)).toThrow(/.*missing required fields*/);
+            expect(() => validateProjectConfig({ srcDir: '.' }, projectDir)).toThrow(/missing required field.*name/);
         });
         it('rejects configuration with missing srcDir', () => {
             expect(() => 
             // @ts-ignore Testing invalid input
-            validateProjectConfig({ name: 'hello' }, projectDir)).toThrow(/.*missing required fields.*/);
+            validateProjectConfig({ name: 'hello' }, projectDir)).toThrow(/missing required field.*srcDir/);
+        });
+        it('rejects configuration with both name and srcDir missing', () => {
+            // @ts-ignore Testing invalid input
+            expect(() => validateProjectConfig({}, projectDir)).toThrow(/missing required fields:.*name.*srcDir/);
         });
         describe('rejects configuration with srcDir outside project directory', () => {
             it('for parent directory', () => {

package/lib/projects/components.d.ts

@@ -1,5 +1,11 @@
 import { Collision } from '@hubspot/local-dev-lib/types/Archive';
 import type { ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+export interface ComponentInfo {
+    filename?: string;
+    isNew: boolean;
+}
+export type ComponentsByType = Map<string, ComponentInfo[]>;
+export declare function buildProjectTree(projectName: string, uids: string[], componentsByType: ComponentsByType, showOnlyNew: boolean): string;
 export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
 export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[], options?: {
     currentProjectMetadata?: ProjectMetadata;

package/lib/projects/components.js

@@ -12,7 +12,7 @@ import { renderInline } from '../../ui/render.js';
 import { getSuccessBox } from '../../ui/components/StatusMessageBoxes.js';
 // Prefix for the metafile extension
 const metafileExtensionPrefix = path.parse(metafileExtension).name;
-function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
+export function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
     const lines = [];
     lines.push(chalk.bold(projectName));
     const types = Array.from(componentsByType.keys());