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

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

@@ -11,7 +11,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
     };
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+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';
@@ -67,6 +67,8 @@ describe('AppDevModeInterface', () => {
             componentRoot: '/test/path',
             componentConfigPath: '/test/path/config.json',
             configUpdatedSinceLastUpload: false,
+            removed: false,
+            parsingErrors: [],
         },
         componentDeps: {},
         metaFilePath: '/test/path',
@@ -107,8 +109,8 @@ describe('AppDevModeInterface', () => {
         LocalDevState.mockImplementation(() => mockLocalDevState);
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
         // Mock external dependencies
-        fetchPublicAppsForPortal.mockResolvedValue({
-            data: { results: [mockPublicApp] },
+        fetchAppMetadataByUid.mockResolvedValue({
+            data: mockPublicApp,
         });
         fetchPublicAppProductionInstallCounts.mockResolvedValue({
             data: { uniquePortalInstallCount: 5 },
@@ -189,12 +191,12 @@ describe('AppDevModeInterface', () => {
         it('should return early if no app node exists', async () => {
             mockLocalDevState.projectNodes = {};
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).not.toHaveBeenCalled();
+            expect(fetchAppMetadataByUid).not.toHaveBeenCalled();
             expect(UIEDevModeInterface.setup).not.toHaveBeenCalled();
         });
         it('should setup successfully with private app', async () => {
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).toHaveBeenCalledWith(12345);
+            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();
@@ -302,32 +304,10 @@ describe('AppDevModeInterface', () => {
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
-            fetchPublicAppsForPortal.mockRejectedValue(error);
+            fetchAppMetadataByUid.mockRejectedValue(error);
             await appDevModeInterface.setup({});
             expect(logError).toHaveBeenCalledWith(error);
         });
-        it('should exit if app not found in portal', async () => {
-            // Set up conditions for non-automatic installation to force getAppInstallUrl call
-            getAccountConfig.mockReturnValue(null);
-            // First call for fetchAppData succeeds
-            fetchPublicAppsForPortal
-                .mockResolvedValueOnce({
-                data: { results: [mockPublicApp] },
-            })
-                // Second call for getAppInstallUrl fails (app not found)
-                .mockResolvedValueOnce({
-                data: { results: [] },
-            });
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            // The setup method catches the error, so we check that process.exit was called
-            await appDevModeInterface.setup({});
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
         // @TODO: Restore test account auto install functionality
         // it('should exit if user declines auto-install', async () => {
         //   // Set up conditions for automatic installation
@@ -424,8 +404,8 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
@@ -457,8 +437,8 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
@@ -501,8 +481,8 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },

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' },
@@ -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
@@ -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__/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 {};

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

@@ -0,0 +1,82 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { vi } from 'vitest';
+import { validateSourceDirectory } from '../upload.js';
+import { uiLogger } from '../../ui/logger.js';
+import { lib } from '../../../lang/en.js';
+import { isV2Project } from '../platformVersion.js';
+import ProjectValidationError from '../../errors/ProjectValidationError.js';
+import { walk } from '@hubspot/local-dev-lib/fs';
+// Mock dependencies
+vi.mock('../../ui/logger.js');
+vi.mock('../platformVersion.js');
+vi.mock('@hubspot/local-dev-lib/fs');
+describe('lib/projects/upload', () => {
+    describe('validateSourceDirectory', () => {
+        let tempDir;
+        let srcDir;
+        let projectConfig;
+        beforeEach(() => {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'upload-test-'));
+            srcDir = path.join(tempDir, 'src');
+            fs.mkdirSync(srcDir, { recursive: true });
+            projectConfig = {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            };
+            vi.clearAllMocks();
+        });
+        afterEach(() => {
+            fs.removeSync(tempDir);
+        });
+        it('should throw ProjectValidationError when source directory is empty', async () => {
+            vi.mocked(walk).mockResolvedValue([]);
+            await expect(validateSourceDirectory(srcDir, projectConfig, tempDir)).rejects.toThrow(ProjectValidationError);
+            expect(walk).toHaveBeenCalledWith(srcDir, ['node_modules']);
+        });
+        it('should warn about legacy files in V3 projects', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const legacyFilePath = path.join(srcDir, 'app', 'serverless.json');
+            vi.mocked(walk).mockResolvedValue([legacyFilePath]);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app/serverless.json', '2025.2'));
+        });
+        it('should warn about multiple legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'app1', 'serverless.json'),
+                path.join(srcDir, 'app2', 'app.json'),
+                path.join(srcDir, 'app3', 'public-app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledTimes(3);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app1/serverless.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app2/app.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app3/public-app.json', '2025.2'));
+        });
+        it('should not warn about non-legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'component.js'),
+                path.join(srcDir, 'config.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).not.toHaveBeenCalled();
+        });
+        it('should not warn about legacy files in non-V3 projects', async () => {
+            vi.mocked(isV2Project).mockReturnValue(false);
+            projectConfig.platformVersion = '2025.1';
+            const filePaths = [
+                path.join(srcDir, 'app', 'serverless.json'),
+                path.join(srcDir, 'app', 'app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -2,7 +2,7 @@ import { legacyAddComponent } from '../legacyAddComponent.js';
 import { findProjectComponents } from '../../structure.js';
 import { getProjectComponentListFromRepo } from '../../create/legacy.js';
 import { projectAddPrompt } from '../../../prompts/projectAddPrompt.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../../ui/logger.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { trackCommandUsage } from '../../../usageTracking.js';
 import { ComponentTypes, } from '../../../../types/Projects.js';
@@ -10,13 +10,13 @@ import { commands } from '../../../../lang/en.js';
 vi.mock('../../structure');
 vi.mock('../../create/legacy');
 vi.mock('../../../prompts/projectAddPrompt');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('../../../usageTracking.js');
 const mockedFindProjectComponents = vi.mocked(findProjectComponents);
 const mockedGetProjectComponentListFromRepo = vi.mocked(getProjectComponentListFromRepo);
 const mockedProjectAddPrompt = vi.mocked(projectAddPrompt);
-const mockedLogger = vi.mocked(logger);
+const mockedUiLogger = vi.mocked(uiLogger);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
 const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/legacyAddComponent', () => {
@@ -75,8 +75,8 @@ describe('lib/projects/add/legacyAddComponent', () => {
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'module',
             }, accountId);
-            expect(mockedLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
-            expect(mockedLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
+            expect(mockedUiLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
         });
         it('throws an error when project contains a public app', async () => {
             const mockComponents = [
@@ -206,7 +206,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
             await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
             expect(mockedCloneGithubRepo).toHaveBeenCalled();
-            expect(mockedLogger.success).not.toHaveBeenCalled();
+            expect(mockedUiLogger.success).not.toHaveBeenCalled();
         });
         it('calls trackCommandUsage with correct component type', async () => {
             const mockComponents = [

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

@@ -5,7 +5,7 @@ import { createV3App } from '../../create/v3.js';
 import { confirmPrompt } from '../../../prompts/promptUtils.js';
 import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../../ui/logger.js';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { trackCommandUsage } from '../../../usageTracking.js';
 import { commands } from '../../../../lang/en.js';
@@ -15,7 +15,7 @@ vi.mock('../../create/legacy');
 vi.mock('../../create/v3');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
 vi.mock('../../../usageTracking');
 const mockedFs = vi.mocked(fs);
@@ -24,7 +24,7 @@ const mockedConfirmPrompt = vi.mocked(confirmPrompt);
 const mockedCreateV3App = vi.mocked(createV3App);
 const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
-const mockedLogger = vi.mocked(logger);
+const mockedUiLogger = vi.mocked(uiLogger);
 const mockedGetProjectMetadata = vi.mocked(getProjectMetadata);
 const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/v3AddComponent', () => {
@@ -100,7 +100,7 @@ describe('lib/projects/add/v3AddComponent', () => {
                 hideLogs: true,
                 branch: 'main',
             }));
-            expect(mockedLogger.success).toHaveBeenCalled();
+            expect(mockedUiLogger.success).toHaveBeenCalled();
         });
         it('creates an app when no app exists and user confirms', async () => {
             const mockProjectMetadataNoApps = {