@hubspot/cli 7.7.31-experimental.0 → 7.7.33-experimental.0

package/lib/__tests__/hasFeature.test.js

@@ -1,35 +1,173 @@
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { hasFeature } from '../hasFeature.js';
+import { http } from '@hubspot/local-dev-lib/http';
+import { hasFeature, hasUnfiedAppsAccess } from '../hasFeature.js';
+import { FEATURES } from '../constants.js';
 vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
+vi.mock('@hubspot/local-dev-lib/http');
 const mockedFetchEnabledFeatures = fetchEnabledFeatures;
+const mockedHttp = http;
 describe('lib/hasFeature', () => {
     describe('hasFeature()', () => {
         const accountId = 123;
-        beforeEach(() => {
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should return true if the feature is enabled', async () => {
             mockedFetchEnabledFeatures.mockResolvedValueOnce({
                 data: {
                     enabledFeatures: {
                         'feature-1': true,
-                        'feature-2': false,
-                        'feature-3': true,
                     },
                 },
             });
-        });
-        it('should return true if the feature is enabled', async () => {
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-1');
             expect(result).toBe(true);
         });
-        it('should return false if the feature is not enabled', async () => {
+        it('should return false if the feature is disabled', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-2': false,
+                    },
+                },
+            });
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-2');
             expect(result).toBe(false);
         });
         it('should return false if the feature is not present', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {},
+                },
+            });
             // @ts-expect-error test data
             const result = await hasFeature(accountId, 'feature-4');
             expect(result).toBe(false);
         });
+        it('should return true for APPS_HOME feature when not present in enabled features (defaults on)', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {},
+                },
+            });
+            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
+            expect(result).toBe(true);
+        });
+        it('should respect explicit setting for APPS_HOME feature even when it defaults on', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        [FEATURES.APPS_HOME]: false,
+                    },
+                },
+            });
+            const result = await hasFeature(accountId, FEATURES.APPS_HOME);
+            expect(result).toBe(false);
+        });
+        it('should handle truthy values correctly', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-truthy': 'yes',
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const truthyResult = await hasFeature(accountId, 'feature-truthy');
+            expect(truthyResult).toBe(true);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-number': 1,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const numberResult = await hasFeature(accountId, 'feature-number');
+            expect(numberResult).toBe(true);
+        });
+        it('should handle falsy values correctly', async () => {
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-null': null,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const nullResult = await hasFeature(accountId, 'feature-null');
+            expect(nullResult).toBe(false);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-zero': 0,
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const zeroResult = await hasFeature(accountId, 'feature-zero');
+            expect(zeroResult).toBe(false);
+            mockedFetchEnabledFeatures.mockResolvedValueOnce({
+                data: {
+                    enabledFeatures: {
+                        'feature-empty': '',
+                    },
+                },
+            });
+            // @ts-expect-error test data
+            const emptyResult = await hasFeature(accountId, 'feature-empty');
+            expect(emptyResult).toBe(false);
+        });
+        it('should propagate errors from fetchEnabledFeatures', async () => {
+            const error = new Error('API error');
+            mockedFetchEnabledFeatures.mockRejectedValueOnce(error);
+            await expect(hasFeature(accountId, FEATURES.UNIFIED_APPS)).rejects.toThrow('API error');
+        });
+    });
+    describe('hasUnfiedAppsAccess()', () => {
+        const accountId = 123;
+        afterEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should return true when API returns true', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: true });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(true);
+            expect(mockedHttp.get).toHaveBeenCalledWith(accountId, {
+                url: 'developer-tooling/external/developer-portal/has-unified-dev-platform-access',
+            });
+        });
+        it('should return false when API returns false', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: false });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should handle truthy values correctly', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: 'yes' });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(true);
+        });
+        it('should handle falsy values correctly', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: null });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should handle undefined response data', async () => {
+            // @ts-expect-error Don't want to mock the full response object
+            mockedHttp.get.mockResolvedValueOnce({ data: undefined });
+            const result = await hasUnfiedAppsAccess(accountId);
+            expect(result).toBe(false);
+        });
+        it('should propagate errors from http.get', async () => {
+            const error = new Error('Network error');
+            mockedHttp.get.mockRejectedValueOnce(error);
+            await expect(hasUnfiedAppsAccess(accountId)).rejects.toThrow('Network error');
+        });
     });
 });

package/lib/__tests__/importData.test.js

@@ -43,7 +43,7 @@ describe('lib/importData', () => {
                 data: { id: '123' },
             });
             await handleImportData(targetAccountId, dataFileNames, importRequest);
-            expect(mockUiLogger.success).toHaveBeenCalledWith(lib.importData.viewImportLink('https://app.hubspot.com', targetAccountId, '123'));
+            expect(mockUiLogger.info).toHaveBeenCalledWith(lib.importData.viewImportLink('https://app.hubspot.com', targetAccountId, '123'));
         });
         it('should log the correct error message', async () => {
             mockCreateImport.mockRejectedValue(new Error('test-error'));

package/lib/app/migrate.js

@@ -22,7 +22,7 @@ import { hasUnfiedAppsAccess } from '../hasFeature.js';
 import { getProjectBuildDetailUrl, getProjectDetailUrl, } from '../projects/urls.js';
 import { uiLogger } from '../ui/logger.js';
 import { debugError } from '../errorHandlers/index.js';
-import { useV3Api } from '../projects/buildAndDeploy.js';
+import { useV3Api } from '../projects/platformVersion.js';
 export function getUnmigratableReason(reasonCode, projectName, accountId) {
     switch (reasonCode) {
         case UNMIGRATABLE_REASONS.UP_TO_DATE:
@@ -236,13 +236,20 @@ export async function handleThemesMigration(projectConfig, platformVersion) {
         throw new Error(lib.migrate.errors.project.invalidConfig);
     }
     const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    let migrated = false;
+    let failureReason;
     try {
-        await migrateThemes(projectConfig.projectDir, projectSrcDir);
+        const migrationResult = await migrateThemes(projectConfig.projectDir, projectSrcDir);
+        migrated = migrationResult.migrated;
+        failureReason = migrationResult.failureReason;
     }
     catch (error) {
         debugError(error);
         throw new Error(lib.migrate.errors.project.failedToMigrateThemes);
     }
+    if (!migrated) {
+        throw new Error(failureReason || lib.migrate.errors.project.failedToMigrateThemes);
+    }
     const newProjectConfig = { ...projectConfig.projectConfig };
     newProjectConfig.platformVersion = platformVersion;
     const projectConfigPath = path.join(projectConfig.projectDir, PROJECT_CONFIG_FILE);

package/lib/constants.d.ts

@@ -80,6 +80,8 @@ export declare const FEATURES: {
     readonly UNIFIED_APPS: "Developers:UnifiedApps:PrivateBeta";
     readonly SANDBOXES_V2: "sandboxes:v2:enabled";
     readonly SANDBOXES_V2_CLI: "sandboxes:v2:cliEnabled";
+    readonly APP_EVENTS: "Developers:UnifiedApps:AppEventsAccess";
+    readonly APPS_HOME: "UIE:AppHome";
 };
 export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPLOAD_SUCCESS: string;

package/lib/constants.js

@@ -72,6 +72,8 @@ export const FEATURES = {
     UNIFIED_APPS: 'Developers:UnifiedApps:PrivateBeta',
     SANDBOXES_V2: 'sandboxes:v2:enabled',
     SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
+    APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
+    APPS_HOME: 'UIE:AppHome',
 };
 export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPLOAD_SUCCESS: 'server:uploadSuccess',

package/lib/errorHandlers/index.d.ts

@@ -12,3 +12,7 @@ export declare class ApiErrorContext {
         projectName?: string;
     });
 }
+export declare function isErrorWithMessageOrReason(error: unknown): error is {
+    message?: string;
+    reason?: string;
+};

package/lib/errorHandlers/index.js

@@ -85,7 +85,7 @@ export class ApiErrorContext {
         this.projectName = props.projectName || '';
     }
 }
-function isErrorWithMessageOrReason(error) {
+export function isErrorWithMessageOrReason(error) {
     return (typeof error === 'object' &&
         error !== null &&
         ('message' in error || 'reason' in error));

package/lib/hasFeature.js

@@ -1,7 +1,13 @@
 import { http } from '@hubspot/local-dev-lib/http';
 import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { FEATURES } from './constants.js';
+const FEATURES_THAT_DEFAULT_ON = [FEATURES.APPS_HOME];
 export async function hasFeature(accountId, feature) {
     const { data: { enabledFeatures }, } = await fetchEnabledFeatures(accountId);
+    if (enabledFeatures[feature] === undefined &&
+        FEATURES_THAT_DEFAULT_ON.includes(feature)) {
+        return true;
+    }
     return Boolean(enabledFeatures[feature]);
 }
 export async function hasUnfiedAppsAccess(accountId) {

package/lib/importData.js

@@ -10,7 +10,7 @@ export async function handleImportData(targetAccountId, dataFileNames, importReq
         const baseUrl = getHubSpotWebsiteOrigin(getEnv());
         const response = await createImport(targetAccountId, importRequest, dataFileNames);
         const importId = response.data.id;
-        uiLogger.success(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
+        uiLogger.info(lib.importData.viewImportLink(baseUrl, targetAccountId, importId));
     }
     catch (error) {
         uiLogger.error(lib.importData.errors.failedToImportData);

package/lib/mcp/setup.js

@@ -182,7 +182,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
                 });
                 await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
             SpinniesManager.succeed('claudeCode', {
                 text: commands.mcp.setup.spinners.configuredClaudeCode,
             });

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,12 +38,7 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return {
-            ...profile,
-            accountId: process.env.HUBSPOT_ACCOUNT_ID
-                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
-                : profile.accountId,
-        };
+        return profile;
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -59,7 +54,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -68,9 +63,6 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
-        if (useEnv) {
-            return Number(process.env.HUBSPOT_ACCOUNT_ID);
-        }
         return profile.accountId;
     }
     else {

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

@@ -240,16 +240,21 @@ describe('AppDevModeInterface', () => {
             await newAppDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(0);
         });
-        it('should auto-install static auth app on test account', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            await appDevModeInterface.setup({});
-            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
-        });
+        // @TODO: Restore test account auto install functionality
+        // it('should auto-install static auth app on test account', async () => {
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   await appDevModeInterface.setup({});
+        //   expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(
+        //     123,
+        //     67890,
+        //     [1, 2, 3]
+        //   );
+        // });
         it('should open browser for OAuth app installation', async () => {
             const oauthAppNode = {
                 ...mockAppNode,
@@ -288,7 +293,12 @@ describe('AppDevModeInterface', () => {
                 },
             });
             await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true, {
+                appUid: 'test-app-uid',
+                projectAccountId: 12345,
+                projectName: 'test-project',
+                testingAccountId: 67890,
+            });
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
@@ -318,39 +328,46 @@ describe('AppDevModeInterface', () => {
             await appDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(1);
         });
-        it('should exit if user declines auto-install', async () => {
-            // Set up conditions for automatic installation
-            getAccountConfig.mockReturnValue({
-                parentAccountId: 12345, // matches targetProjectAccountId
-            });
-            isDeveloperTestAccount.mockReturnValue(true);
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installAppAutoPrompt.mockResolvedValue(false);
-            // Create a new instance to trigger the exit during setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            // The setup method catches the error, so we check that process.exit was called
-            await newAppDevModeInterface.setup({});
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-        it('should fallback to browser install if auto-install fails', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
-            await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
-        });
+        // @TODO: Restore test account auto install functionality
+        // it('should exit if user declines auto-install', async () => {
+        //   // Set up conditions for automatic installation
+        //   (getAccountConfig as Mock).mockReturnValue({
+        //     parentAccountId: 12345, // matches targetProjectAccountId
+        //   });
+        //   (isDeveloperTestAccount as Mock).mockReturnValue(true);
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   (installAppAutoPrompt as Mock).mockResolvedValue(false);
+        //   // Create a new instance to trigger the exit during setup
+        //   const newAppDevModeInterface = new AppDevModeInterface({
+        //     localDevState: mockLocalDevState,
+        //     localDevLogger: mockLocalDevLogger,
+        //   });
+        //   // The setup method catches the error, so we check that process.exit was called
+        //   await newAppDevModeInterface.setup({});
+        //   expect(process.exit).toHaveBeenCalledWith(0);
+        // });
+        // @TODO: Restore test account auto install functionality
+        // it('should fallback to browser install if auto-install fails', async () => {
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   (installStaticAuthAppOnTestAccount as Mock).mockRejectedValue(
+        //     new Error('Install failed')
+        //   );
+        //   await appDevModeInterface.setup({});
+        //   expect(installAppBrowserPrompt).toHaveBeenCalledWith(
+        //     'http://static-install-url',
+        //     false
+        //   );
+        // });
     });
     describe('start()', () => {
         it('should return early if no app node exists', async () => {

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

@@ -39,6 +39,7 @@ describe('LocalDevProcess', () => {
         targetTestingAccountId: 456,
         projectId: 789,
         initialProjectNodes: {},
+        initialProjectProfileData: {},
         env: ENVIRONMENTS.PROD,
         projectName: 'test-project',
     };

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

@@ -0,0 +1,164 @@
+import { vi } from 'vitest';
+import { validateBuildIdForDeploy, logDeployErrors, handleProjectDeploy, } from '../deploy.js';
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../../constants.js';
+import { deployProject } from '@hubspot/local-dev-lib/api/projects';
+import { pollDeployStatus } from '../pollProjectBuildAndDeploy.js';
+// Mock external dependencies
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('../pollProjectBuildAndDeploy.js');
+const mockUiLogger = vi.mocked(uiLogger);
+const mockDeployProject = vi.mocked(deployProject);
+const mockPollDeployStatus = vi.mocked(pollDeployStatus);
+describe('lib/projects/deploy', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('validateBuildIdForDeploy()', () => {
+        const accountId = 12345;
+        const projectName = 'test-project';
+        it('returns true when build ID is valid for deployment', () => {
+            const buildId = 5;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(true);
+        });
+        it('returns error message when build ID does not exist', () => {
+            const buildId = 15;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName));
+        });
+        it('returns error message when build is already deployed', () => {
+            const buildId = 3;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName));
+        });
+        it('handles edge case when deployedBuildId is undefined', () => {
+            const buildId = 5;
+            const deployedBuildId = undefined;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(true);
+        });
+    });
+    describe('logDeployErrors()', () => {
+        it('logs main error message and individual error messages', () => {
+            const errorData = {
+                message: 'Deploy failed with errors',
+                errors: [
+                    {
+                        message: 'Component error 1',
+                        subCategory: 'SOME_ERROR',
+                        context: { COMPONENT_NAME: 'test-component' },
+                    },
+                    {
+                        message: 'Component error 2',
+                        subCategory: 'ANOTHER_ERROR',
+                        context: { COMPONENT_NAME: 'another-component' },
+                    },
+                ],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('Deploy failed with errors');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Component error 1');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Component error 2');
+        });
+        it('handles DEPLOY_CONTAINS_REMOVALS error type specially', () => {
+            const errorData = {
+                message: 'Deploy contains removals',
+                errors: [
+                    {
+                        message: 'Component will be removed',
+                        subCategory: PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS,
+                        context: { COMPONENT_NAME: 'removed-component' },
+                    },
+                ],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('Deploy contains removals');
+            expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployContainsRemovals('removed-component'));
+        });
+        it('handles empty errors array', () => {
+            const errorData = {
+                message: 'No specific errors',
+                errors: [],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('No specific errors');
+            expect(mockUiLogger.log).not.toHaveBeenCalled();
+        });
+    });
+    describe('handleProjectDeploy()', () => {
+        const targetAccountId = 12345;
+        const projectName = 'test-project';
+        const buildId = 5;
+        const useV3Api = true;
+        const force = false;
+        it('successfully deploys and returns deploy result', async () => {
+            const mockDeployResponseData = {
+                id: 'deploy-123',
+                buildResultType: 'DEPLOY_QUEUED',
+                links: {
+                    status: 'http://status-url',
+                },
+            };
+            const mockDeployResult = {
+                deployId: 123,
+                buildId: 5,
+                status: 'SUCCESS',
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: targetAccountId,
+                projectName: 'test-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+                subdeployStatuses: [],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockDeployResponseData,
+            });
+            mockPollDeployStatus.mockResolvedValue(mockDeployResult);
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(result).toEqual(mockDeployResult);
+        });
+        it('handles blocked deploy with warnings', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [
+                            {
+                                message: 'This is a warning',
+                                isWarning: true,
+                            },
+                        ],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
+            expect(result).toBeUndefined();
+        });
+        it('handles general deploy failure', async () => {
+            mockDeployProject.mockResolvedValue({ data: null });
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
+            expect(result).toBeUndefined();
+        });
+    });
+});

package/lib/projects/__tests__/{buildAndDeploy.test.js → platformVersion.test.js}

@@ -1,5 +1,5 @@
-import { useV3Api } from '../buildAndDeploy.js';
-describe('buildAndDeploy', () => {
+import { useV3Api } from '../platformVersion.js';
+describe('platformVersion', () => {
     describe('useV3Api', () => {
         it('returns true if platform version is UNSTABLE', () => {
             expect(useV3Api('UNSTABLE')).toBe(true);