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

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

@@ -1,12 +1,12 @@
 import { WebSocketServer } from 'ws';
 import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { logger } from '@hubspot/local-dev-lib/logger';
+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');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../ui/logger.js');
 describe('LocalDevWebsocketServer', () => {
     let mockLocalDevProcess;
     let mockWebSocket;
@@ -59,39 +59,68 @@ describe('LocalDevWebsocketServer', () => {
             await server.start();
             expect(WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
             expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
-            expect(logger.log).toHaveBeenCalled();
+            expect(uiLogger.log).toHaveBeenCalled();
         });
-        it('should accept connection from valid origin', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
+        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();
+                });
             });
-            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.hubspot.com' },
-            });
-            expect(mockWebSocket.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
-            expect(mockWebSocket.close).not.toHaveBeenCalled();
         });
-        it('should reject connection from invalid 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: 'https://malicious-site.com' },
+        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();
+                });
             });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
-            expect(mockWebSocket.on).not.toHaveBeenCalled();
-            expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
         });
         it('should reject connection with no origin header', async () => {
             isPortManagerServerRunning.mockResolvedValue(true);
@@ -119,7 +148,7 @@ describe('LocalDevWebsocketServer', () => {
             const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
             // Simulate connection from valid origin
             connectionCallback(mockWebSocket, {
-                headers: { origin: 'https://app.hubspot.com' },
+                headers: { origin: 'https://app-na3.hubspot.com' },
             });
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
@@ -148,7 +177,7 @@ describe('LocalDevWebsocketServer', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const message = {};
             messageCallback(JSON.stringify(message));
-            expect(logger.error).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalled();
         });
         it('should log error for unknown message type', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
@@ -156,13 +185,13 @@ describe('LocalDevWebsocketServer', () => {
                 type: 'UNKNOWN_TYPE',
             };
             messageCallback(JSON.stringify(message));
-            expect(logger.error).toHaveBeenCalled();
+            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(logger.error).toHaveBeenCalled();
+            expect(uiLogger.error).toHaveBeenCalled();
         });
     });
     describe('shutdown()', () => {
@@ -213,7 +242,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app.hubspotqa.com' },
+                headers: { origin: 'https://app-na2.hubspotqa.com' },
             });
             connectionCallback(mockWebSocket3, {
                 headers: { origin: 'https://local.hubspot.com' },
@@ -223,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);
@@ -238,7 +267,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app.hubspotqa.com' },
+                headers: { origin: 'https://app-eu1.hubspotqa.com' },
             });
             // Each websocket should receive project data
             expect(mockWebSocket1.send).toHaveBeenCalledWith(JSON.stringify({
@@ -270,7 +299,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app.hubspotqa.com' },
+                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
@@ -279,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
@@ -296,7 +325,7 @@ describe('LocalDevWebsocketServer', () => {
                 headers: { origin: 'https://app.hubspot.com' },
             });
             connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app.hubspotqa.com' },
+                headers: { origin: 'https://local.hubspotqa.com' },
             });
             // Get the projectNodes listeners that were registered
             const projectNodesListeners = mockLocalDevProcess.addStateListener.mock.calls
@@ -312,6 +341,8 @@ describe('LocalDevWebsocketServer', () => {
                         componentRoot: '/test/path',
                         componentConfigPath: '/test/path/config.json',
                         configUpdatedSinceLastUpload: false,
+                        removed: false,
+                        parsingErrors: [],
                     },
                     componentDeps: {},
                     metaFilePath: '/test/path',

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

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

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

@@ -0,0 +1,161 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import UIExtensionsDevModeInterface from '../localDev/UIExtensionsDevModeInterface.js';
+import LocalDevState from '../localDev/LocalDevState.js';
+import { DevModeUnifiedInterface } from '@hubspot/ui-extensions-dev-server';
+import { requestPorts } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+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/urls', () => ({
+    getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),
+    getHubSpotWebsiteOrigin: vi.fn().mockReturnValue('https://app.hubspot.com'),
+}));
+describe('UIExtensionsDevModeInterface', () => {
+    let uiExtensionsInterface;
+    let mockLocalDevState;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(DevModeUnifiedInterface.setup).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.start).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.fileChange).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.cleanup).mockResolvedValue(undefined);
+        mockLocalDevState = new LocalDevState({
+            targetProjectAccountId: 123,
+            targetTestingAccountId: 456,
+            projectConfig: {
+                name: 'test-ui-extensions-project',
+                srcDir: 'src',
+                platformVersion: '1.0.0',
+            },
+            projectDir: '/test/ui-extensions-project',
+            projectData: {
+                name: 'test-ui-extensions-project',
+                id: 789,
+                createdAt: Date.now(),
+                deletedAt: 0,
+                isLocked: false,
+                portalId: 123,
+                updatedAt: Date.now(),
+            },
+            debug: false,
+            initialProjectNodes: {
+                'test-component': {
+                    uid: 'test-component-uid',
+                    componentType: 'UI_EXTENSION',
+                    config: {
+                        name: 'Test UI Extension',
+                        type: 'card',
+                    },
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                        removed: false,
+                        parsingErrors: [],
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    files: [],
+                },
+            },
+            initialProjectProfileData: {
+                testVariable: 'testValue',
+            },
+            profile: 'test',
+            env: ENVIRONMENTS.QA,
+        });
+        uiExtensionsInterface = new UIExtensionsDevModeInterface({
+            localDevState: mockLocalDevState,
+        });
+    });
+    describe('constructor', () => {
+        it('should store the localDevState reference', () => {
+            expect(uiExtensionsInterface.localDevState).toBe(mockLocalDevState);
+        });
+    });
+    describe('setup', () => {
+        it('should call DevModeUnifiedInterface.setup with correct parameters', async () => {
+            await uiExtensionsInterface.setup();
+            expect(DevModeUnifiedInterface.setup).toHaveBeenCalledWith({
+                components: mockLocalDevState.projectNodes,
+                profileData: mockLocalDevState.projectProfileData,
+                logger,
+                urls: {
+                    api: 'https://api.hubspot.com',
+                    web: 'https://app.hubspot.com',
+                },
+            });
+        });
+        it('should use correct URLs based on environment', async () => {
+            await uiExtensionsInterface.setup();
+            expect(getHubSpotApiOrigin).toHaveBeenCalledWith(mockLocalDevState.env);
+            expect(getHubSpotWebsiteOrigin).toHaveBeenCalledWith(mockLocalDevState.env);
+        });
+        it('should pass project nodes and profile data from state', async () => {
+            await uiExtensionsInterface.setup();
+            const setupCall = vi.mocked(DevModeUnifiedInterface.setup).mock
+                .calls[0][0];
+            expect(setupCall.components).toStrictEqual(mockLocalDevState.projectNodes);
+            expect(setupCall.profileData).toStrictEqual(mockLocalDevState.projectProfileData);
+        });
+    });
+    describe('start', () => {
+        it('should call DevModeUnifiedInterface.start with correct parameters', async () => {
+            await uiExtensionsInterface.start();
+            expect(DevModeUnifiedInterface.start).toHaveBeenCalledWith({
+                accountId: mockLocalDevState.targetTestingAccountId,
+                projectConfig: mockLocalDevState.projectConfig,
+                requestPorts,
+            });
+        });
+        it('should use targetTestingAccountId from state', async () => {
+            await uiExtensionsInterface.start();
+            const startCall = vi.mocked(DevModeUnifiedInterface.start).mock
+                .calls[0][0];
+            expect(startCall.accountId).toBe(456); // targetTestingAccountId
+        });
+        it('should pass project config from state', async () => {
+            await uiExtensionsInterface.start();
+            const startCall = vi.mocked(DevModeUnifiedInterface.start).mock
+                .calls[0][0];
+            expect(startCall.projectConfig).toStrictEqual(mockLocalDevState.projectConfig);
+        });
+    });
+    describe('fileChange', () => {
+        it('should call DevModeUnifiedInterface.fileChange with correct parameters', async () => {
+            const filePath = 'src/components/TestCard.tsx';
+            const event = 'change';
+            await uiExtensionsInterface.fileChange(filePath, event);
+            expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledWith(filePath, event);
+        });
+        it('should handle different file events', async () => {
+            const testCases = [
+                { filePath: 'src/components/Card.tsx', event: 'add' },
+                { filePath: 'src/styles/main.css', event: 'change' },
+                { filePath: 'src/config.json', event: 'unlink' },
+            ];
+            for (const testCase of testCases) {
+                await uiExtensionsInterface.fileChange(testCase.filePath, testCase.event);
+                expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledWith(testCase.filePath, testCase.event);
+            }
+            expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('cleanup', () => {
+        it('should call DevModeUnifiedInterface.cleanup', async () => {
+            await uiExtensionsInterface.cleanup();
+            expect(DevModeUnifiedInterface.cleanup).toHaveBeenCalledWith();
+        });
+    });
+});

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

@@ -99,7 +99,7 @@ describe('lib/projects/deploy', () => {
         const targetAccountId = 12345;
         const projectName = 'test-project';
         const buildId = 5;
-        const useV3Api = true;
+        const useV2Api = true;
         const force = false;
         it('successfully deploys and returns deploy result', async () => {
             const mockDeployResponseData = {
@@ -126,8 +126,8 @@ describe('lib/projects/deploy', () => {
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue(mockDeployResult);
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV2Api, force);
             expect(deploy).toEqual(mockDeployResult);
         });
         it('handles blocked deploy with warnings', async () => {
@@ -150,7 +150,7 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
         });
         it('handles blocked deploy with errors (cannot be forced)', async () => {
@@ -173,7 +173,7 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deployBlockedHeader);
             expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployIssueComponentWarning('component-1', 'module', 'This is an error'));
         });
@@ -192,19 +192,19 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
             expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployIssueComponentGeneric('component-1', 'module'));
         });
         it('handles general deploy failure', async () => {
             mockDeployProject.mockResolvedValue({ data: null });
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
             expect(deploy).toBeUndefined();
         });
         it('handles undefined deploy response', async () => {
             mockDeployProject.mockResolvedValue({ data: undefined });
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
             expect(deploy).toBeUndefined();
         });
@@ -221,7 +221,7 @@ describe('lib/projects/deploy', () => {
             });
             mockPollDeployStatus.mockResolvedValue({});
             await handleProjectDeploy(targetAccountId, projectName, buildId, false, true);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV3Api
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV2Api
             true // force
             );
         });

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

@@ -30,6 +30,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
             componentRoot: '/local/path',
             componentConfigPath: '/local/path/config.json',
             configUpdatedSinceLastUpload: false,
+            removed: false,
+            parsingErrors: [],
         },
         componentDeps: {},
         metaFilePath: '/local/path',

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

@@ -1,23 +1,23 @@
-import { useV3Api } from '../platformVersion.js';
+import { isV2Project } from '../platformVersion.js';
 describe('platformVersion', () => {
-    describe('useV3Api', () => {
+    describe('isV2Project', () => {
         it('returns true if platform version is UNSTABLE', () => {
-            expect(useV3Api('UNSTABLE')).toBe(true);
+            expect(isV2Project('UNSTABLE')).toBe(true);
         });
         it('returns true if platform version is equal to the minimum', () => {
-            expect(useV3Api('2025.2')).toBe(true);
+            expect(isV2Project('2025.2')).toBe(true);
         });
         it('returns true if platform version is greater than the minimum', () => {
-            expect(useV3Api('2026.2')).toBe(true);
+            expect(isV2Project('2026.2')).toBe(true);
         });
         it('returns false if platform version is less than the minimum', () => {
-            expect(useV3Api('2025.0')).toBe(false);
+            expect(isV2Project('2025.0')).toBe(false);
         });
         it('returns false if platform version is invalid', () => {
-            expect(useV3Api(null)).toBe(false);
+            expect(isV2Project(null)).toBe(false);
         });
         it('returns false for an invalid platform version', () => {
-            expect(useV3Api('notplaformversion')).toBe(false);
+            expect(isV2Project('notplaformversion')).toBe(false);
         });
     });
 });

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

@@ -3,8 +3,8 @@ import os from 'os';
 import path from 'path';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { validateProjectConfig } from '../../projects/config.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
-vi.mock('@hubspot/local-dev-lib/logger');
+import { uiLogger } from '../../ui/logger.js';
+vi.mock('../../ui/logger.js');
 describe('lib/projects', () => {
     describe('validateProjectConfig()', () => {
         let projectDir;
@@ -26,58 +26,58 @@ describe('lib/projects', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig(null, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
         });
         it('rejects configuration with missing name', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig({ srcDir: '.' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
         });
         it('rejects configuration with missing srcDir', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig({ name: 'hello' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
         });
         describe('rejects configuration with srcDir outside project directory', () => {
             it('for parent directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
             });
             it('for root directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
             });
             it('for complicated directory', () => {
                 const srcDir = './src/././../src/../../src';
                 validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
             });
         });
         it('rejects configuration with srcDir that does not exist', () => {
             validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
         });
         describe('accepts configuration with valid srcDir', () => {
             it('for current directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
             it('for relative directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
             it('for implied relative directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
         });
     });

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

@@ -1,11 +1,11 @@
 import fs from 'fs';
 import * as HSfs from '@hubspot/local-dev-lib/fs';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 import { getComponentTypeFromConfigFile, loadConfigFile, getAppCardConfigs, getIsLegacyApp, componentIsApp, findProjectComponents, getProjectComponentTypes, getComponentUid, componentIsPublicApp, } from '../structure.js';
 import { ComponentTypes } from '../../../types/Projects.js';
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/fs');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../ui/logger.js');
 const mockedReadFileSync = fs.readFileSync;
 const mockedWalk = HSfs.walk;
 const getMockPrivateAppConfig = (cards = []) => ({
@@ -46,7 +46,7 @@ describe('lib/projects/structure', () => {
                 throw new Error('File not found');
             });
             expect(loadConfigFile('nonexistent/path/app.json')).toBeNull();
-            expect(logger.debug).toHaveBeenCalled();
+            expect(uiLogger.debug).toHaveBeenCalled();
         });
     });
     describe('getAppCardConfigs()', () => {

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

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