@hubspot/cli 7.8.0-experimental.0 → 7.8.2-experimental.0

package/lib/constants.js

@@ -73,17 +73,25 @@ export const FEATURES = {
     SANDBOXES_V2: 'sandboxes:v2:enabled',
     SANDBOXES_V2_CLI: 'sandboxes:v2:cliEnabled',
     APP_EVENTS: 'Developers:UnifiedApps:AppEventsAccess',
+    APPS_HOME: 'UIE:AppHome',
+    MCP_ACCESS: 'Developers:CLIMCPAccess',
+    THEME_MIGRATION_2025_2: 'Developers:ProjectThemeMigrations:2025.2',
+    AGENT_TOOLS: 'ThirdPartyAgentTools',
 };
 export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPLOAD_SUCCESS: 'server:uploadSuccess',
     UPLOAD_FAILURE: 'server:uploadFailure',
+    DEPLOY_SUCCESS: 'server:deploySuccess',
+    DEPLOY_FAILURE: 'server:deployFailure',
     UPDATE_PROJECT_NODES: 'server:updateProjectNodes',
     UPDATE_APP_DATA: 'server:updateAppData',
     UPDATE_PROJECT_DATA: 'server:updateProjectData',
     UPDATE_UPLOAD_WARNINGS: 'server:updateUploadWarnings',
+    CLI_METADATA: 'server:cliMetadata',
 };
 export const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES = {
     UPLOAD: 'client:upload',
+    DEPLOY: 'client:deploy',
     VIEWED_WELCOME_SCREEN: 'client:viewedWelcomeScreen',
 };
 export const APP_INSTALLATION_STATES = {

package/lib/dependencyManagement.d.ts

@@ -2,10 +2,5 @@ export declare function installPackages({ packages, installLocations, }: {
     packages?: string[];
     installLocations?: string[];
 }): Promise<void>;
-export declare function installPackagesV2({ packages, installLocations, }: {
-    packages?: string[];
-    installLocations?: string[];
-}): Promise<void>;
-export declare function installPackagesInDirectoryV2(directory: string, packages?: string[]): Promise<void>;
 export declare function getProjectPackageJsonLocations(dir?: string): Promise<string[]>;
 export declare function hasMissingPackages(directory: string): Promise<boolean>;

package/lib/dependencyManagement.js

@@ -22,15 +22,6 @@ export async function installPackages({ packages, installLocations, }) {
         await installPackagesInDirectory(dir, packages);
     }));
 }
-export async function installPackagesV2({ packages, installLocations, }) {
-    const installDirs = installLocations || (await getProjectPackageJsonLocations());
-    await Promise.all(installDirs.map(async (dir) => {
-        await installPackagesInDirectoryV2(dir, packages);
-    }));
-}
-export async function installPackagesInDirectoryV2(directory, packages) {
-    await executeInstall(packages, null, { cwd: directory });
-}
 async function installPackagesInDirectory(directory, packages) {
     const spinner = `installingDependencies-${directory}`;
     const relativeDir = path.relative(process.cwd(), directory);

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/links.d.ts

@@ -7,4 +7,5 @@ type SiteLink = {
 export declare function getSiteLinksAsArray(accountId: number): SiteLink[];
 export declare function logSiteLinks(accountId: number): void;
 export declare function openLink(accountId: number, shortcut: string): void;
+export declare function getProductUpdatesUrl(rolloutId: string, accountId?: number): string;
 export {};

package/lib/links.js

@@ -4,7 +4,7 @@ import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { getTableContents, getTableHeader } from './ui/table.js';
-const SITE_LINKS = {
+const COMMON_SITE_LINKS = {
     APPS_MARKETPLACE: {
         shortcut: 'apps-marketplace',
         alias: 'apm',
@@ -76,7 +76,7 @@ const SITE_LINKS = {
 };
 export function getSiteLinksAsArray(accountId) {
     const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
-    return Object.values(SITE_LINKS)
+    return Object.values(COMMON_SITE_LINKS)
         .sort((a, b) => (a.shortcut < b.shortcut ? -1 : 1))
         .map(l => ({ ...l, url: l.getUrl(accountId, baseUrl) }));
 }
@@ -90,7 +90,7 @@ export function logSiteLinks(accountId) {
     logger.log(getTableContents(linksAsArray));
 }
 export function openLink(accountId, shortcut) {
-    const match = Object.values(SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
+    const match = Object.values(COMMON_SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
     if (!match) {
         logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
         return;
@@ -99,3 +99,10 @@ export function openLink(accountId, shortcut) {
     open(match.getUrl(accountId, baseUrl), { url: true });
     logger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
 }
+export function getProductUpdatesUrl(rolloutId, accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    if (accountId) {
+        return `${baseUrl}/product-updates/${accountId}/in-beta?rollout=${rolloutId}`;
+    }
+    return `${baseUrl}/l/product-updates/in-beta?rollout=${rolloutId}`;
+}

package/lib/mcp/setup.js

@@ -8,7 +8,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { existsSync } from 'fs';
-const mcpServerName = 'hubspot-cli-mcp';
+const mcpServerName = 'HubSpotDev';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';

package/lib/middleware/fireAlarmMiddleware.js

@@ -3,6 +3,8 @@ import { fetchFireAlarms } from '@hubspot/local-dev-lib/api/fireAlarm';
 import { debugError } from '../errorHandlers/index.js';
 import pkg from '../../package.json' with { type: 'json' };
 import { logInBox } from '../ui/boxen.js';
+import { renderInline } from '../../ui/index.js';
+import { getWarningBox } from '../../ui/components/StatusMessageBoxes.js';
 /*
  * Versions can be formatted like this:
  * =7.2.2 -> targets the exact version 7.2.2
@@ -98,12 +100,20 @@ async function logFireAlarms(accountId, command, version) {
             }
             return acc;
         }, '');
-        await logInBox({
-            contents: notifications,
-            options: {
+        if (!process.env.HUBSPOT_ENABLE_INK) {
+            await logInBox({
+                contents: notifications,
+                options: {
+                    title: 'Notifications',
+                },
+            });
+        }
+        else {
+            await renderInline(getWarningBox({
                 title: 'Notifications',
-            },
-        });
+                message: notifications,
+            }));
+        }
     }
 }
 export async function checkFireAlarms(argv) {

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

@@ -1,7 +1,10 @@
 import path from 'path';
 import { translateForLocalDev } from '@hubspot/project-parsing-lib';
 import { handleProjectUpload } from '../upload.js';
+import { handleProjectDeploy } from '../deploy.js';
 import { getProjectConfig } from '../config.js';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import LocalDevProcess from '../localDev/LocalDevProcess.js';
 import LocalDevLogger from '../localDev/LocalDevLogger.js';
 import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
@@ -19,7 +22,10 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => ({
 vi.mock('open');
 vi.mock('@hubspot/project-parsing-lib');
 vi.mock('../upload');
+vi.mock('../deploy');
 vi.mock('../config');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('../localDev/LocalDevLogger');
 vi.mock('../localDev/DevServerManagerV2');
 // Tests for LocalDevProcess and LocalDevState
@@ -37,11 +43,35 @@ describe('LocalDevProcess', () => {
         projectConfig: mockProjectConfig,
         targetProjectAccountId: 123,
         targetTestingAccountId: 456,
-        projectId: 789,
+        projectData: {
+            id: 789,
+            name: 'test-project',
+            portalId: 123,
+            createdAt: 0,
+            deletedAt: 0,
+            isLocked: false,
+            updatedAt: 0,
+            latestBuild: {
+                activitySource: { type: 'HUBSPOT_USER', userId: 456 },
+                buildId: 123,
+                createdAt: '2023-01-01T00:00:00Z',
+                deployableState: 'DEPLOYABLE',
+                deployStatusTaskLocator: { id: 'task-123', links: [] },
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                isAutoDeployEnabled: false,
+                portalId: 123,
+                projectName: 'test-project',
+                startedAt: '2023-01-01T00:01:00Z',
+                status: 'SUCCESS',
+                subbuildStatuses: [],
+                uploadMessage: 'Build completed',
+                autoDeployId: 0,
+            },
+        },
         initialProjectNodes: {},
         initialProjectProfileData: {},
         env: ENVIRONMENTS.PROD,
-        projectName: 'test-project',
     };
     beforeEach(() => {
         vi.clearAllMocks();
@@ -62,6 +92,9 @@ describe('LocalDevProcess', () => {
             uploadSuccess: vi.fn(),
             fileChangeError: vi.fn(),
             uploadWarning: vi.fn(),
+            deployInitiated: vi.fn(),
+            deployError: vi.fn(),
+            deploySuccess: vi.fn(),
         };
         mockDevServerManager = {
             setup: vi.fn().mockResolvedValue(undefined),
@@ -72,6 +105,8 @@ describe('LocalDevProcess', () => {
         // Mock constructors
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
         DevServerManagerV2.mockImplementation(() => mockDevServerManager);
+        // Mock external functions
+        isHubSpotHttpError.mockReturnValue(false);
         // Create process instance
         process = new LocalDevProcess(mockOptions);
         // Mock process.exit
@@ -141,9 +176,14 @@ describe('LocalDevProcess', () => {
             handleProjectUpload.mockResolvedValue({
                 uploadError: new Error('Upload failed'),
             });
-            const success = await process.uploadProject();
+            const result = await process.uploadProject();
             expect(mockLocalDevLogger.uploadError).toHaveBeenCalledWith(new Error('Upload failed'));
-            expect(success).toBe(false);
+            expect(result).toEqual({
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+                deployId: undefined,
+            });
         });
         it('should handle successful upload', async () => {
             await process.handleConfigFileChange();
@@ -152,38 +192,120 @@ describe('LocalDevProcess', () => {
             });
             handleProjectUpload.mockResolvedValue({
                 uploadError: null,
+                result: {
+                    deployResult: {
+                        id: 'deploy-123',
+                        deployId: 123,
+                        status: 'SUCCESS',
+                    },
+                },
+            });
+            fetchProject.mockResolvedValue({
+                data: {
+                    id: 789,
+                    name: 'test-project',
+                    portalId: 123,
+                    createdAt: 0,
+                    deletedAt: 0,
+                    isLocked: false,
+                    updatedAt: 0,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+                },
             });
-            const success = await process.uploadProject();
+            const result = await process.uploadProject();
+            expect(fetchProject).toHaveBeenCalledWith(mockOptions.targetProjectAccountId, mockOptions.projectConfig.name);
             expect(mockLocalDevLogger.uploadSuccess).toHaveBeenCalled();
             // @ts-expect-error accessing private property for testing
             expect(process.state.uploadWarnings.size).toBe(0);
-            expect(success).toBe(true);
+            expect(result).toEqual({
+                uploadSuccess: true,
+                buildSuccess: true,
+                deploySuccess: true,
+                deployId: 123,
+            });
         });
-        it('should reset projectNodesAtLastUpload', async () => {
-            const mockNodes = { node1: { uid: 'node1' } };
-            const initialProjectNodes = { existingNode: { uid: 'existingNode' } };
+        it('should reset projectNodesAtLastUpload if deploy is successful', async () => {
+            const mockInitialNodes = {
+                node1: {
+                    uid: 'node1',
+                    componentType: 'APP',
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    config: { name: 'Node 1' },
+                    files: [],
+                },
+            };
+            const mockNewNodes = {
+                node1: {
+                    uid: 'node2',
+                    componentType: 'APP',
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    config: { name: 'Node 2' },
+                    files: [],
+                },
+            };
             // @ts-expect-error accessing private property for testing
-            process.state._projectNodesAtLastUpload = initialProjectNodes;
+            process.state.projectNodesAtLastDeploy = mockInitialNodes;
             getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
             handleProjectUpload.mockResolvedValue({
                 uploadError: null,
+                result: {
+                    deployResult: {
+                        id: 'deploy-123',
+                        deployId: 456,
+                        status: 'SUCCESS',
+                    },
+                },
             });
             translateForLocalDev.mockResolvedValue({
-                intermediateNodesIndexedByUid: mockNodes,
+                intermediateNodesIndexedByUid: mockNewNodes,
             });
-            const success = await process.uploadProject();
-            // Verify translateForLocalDev was called without projectNodesAtLastUpload option
+            fetchProject.mockResolvedValue({
+                data: {
+                    id: 789,
+                    name: 'test-project',
+                    portalId: 123,
+                    createdAt: 0,
+                    deletedAt: 0,
+                    isLocked: false,
+                    updatedAt: 0,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+                },
+            });
+            const result = await process.uploadProject();
+            // Verify translateForLocalDev was called during updateProjectNodesAfterDeploy
             expect(translateForLocalDev).toHaveBeenCalledWith({
                 projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
-            }, { projectNodesAtLastUpload: undefined });
+            }, {
+                profile: undefined,
+                projectNodesAtLastUpload: undefined,
+            });
             // Verify projectNodesAtLastUpload was reset to the new nodes
             // @ts-expect-error accessing private property for testing
-            expect(process.state.projectNodesAtLastUpload).toEqual(mockNodes);
-            expect(success).toBe(true);
+            expect(process.state.projectNodesAtLastDeploy).toEqual(mockNewNodes);
+            expect(result).toEqual({
+                uploadSuccess: true,
+                buildSuccess: true,
+                deploySuccess: true,
+                deployId: 456,
+            });
         });
     });
     describe('handleFileChange()', () => {
@@ -252,4 +374,93 @@ describe('LocalDevProcess', () => {
             expect(listener).toHaveBeenCalledTimes(1);
         });
     });
+    describe('deployLatestBuild()', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should successfully deploy latest build', async () => {
+            const mockDeploy = {
+                deployId: 456,
+                buildId: 123,
+                status: 'SUCCESS',
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 123,
+                projectName: 'test-project',
+                userId: 789,
+                source: 'HUBSPOT_USER',
+                subdeployStatuses: [],
+            };
+            handleProjectDeploy.mockResolvedValue(mockDeploy);
+            const result = await process.deployLatestBuild();
+            expect(mockLocalDevLogger.deployInitiated).toHaveBeenCalled();
+            expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
+            'test-project', // projectName
+            123, // buildId
+            true, // useV3Api
+            false // force
+            );
+            expect(mockLocalDevLogger.deploySuccess).toHaveBeenCalled();
+            expect(result).toEqual({
+                success: true,
+                deployId: 456,
+            });
+        });
+        it('should deploy with force parameter', async () => {
+            const mockDeploy = {
+                deployId: 456,
+                buildId: 123,
+                status: 'SUCCESS',
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: 123,
+                projectName: 'test-project',
+                userId: 789,
+                source: 'HUBSPOT_USER',
+                subdeployStatuses: [],
+            };
+            handleProjectDeploy.mockResolvedValue(mockDeploy);
+            const result = await process.deployLatestBuild(true);
+            expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
+            'test-project', // projectName
+            123, // buildId
+            true, // useV3Api
+            true // force
+            );
+            expect(result).toEqual({
+                success: true,
+                deployId: 456,
+            });
+        });
+        it('should return error when no build exists', async () => {
+            // Create a process without latestBuild
+            const optionsWithoutBuild = {
+                ...mockOptions,
+                projectData: {
+                    ...mockOptions.projectData,
+                    latestBuild: undefined,
+                },
+            };
+            const processWithoutBuild = new LocalDevProcess(optionsWithoutBuild);
+            const result = await processWithoutBuild.deployLatestBuild();
+            expect(mockLocalDevLogger.deployInitiated).toHaveBeenCalled();
+            expect(mockLocalDevLogger.deployError).toHaveBeenCalledWith('Error deploying project. No build was found to deploy.');
+            expect(result).toEqual({
+                success: false,
+            });
+            expect(handleProjectDeploy).not.toHaveBeenCalled();
+        });
+        it('should handle deploy failure when no deploy object returned', async () => {
+            handleProjectDeploy.mockResolvedValue(undefined);
+            const result = await process.deployLatestBuild();
+            expect(mockLocalDevLogger.deployInitiated).toHaveBeenCalled();
+            expect(handleProjectDeploy).toHaveBeenCalled();
+            expect(result).toEqual({
+                success: false,
+            });
+            expect(mockLocalDevLogger.deploySuccess).not.toHaveBeenCalled();
+        });
+    });
 });

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

@@ -30,8 +30,16 @@ describe('LocalDevWebsocketServer', () => {
         mockLocalDevProcess = {
             addStateListener: vi.fn(),
             removeStateListener: vi.fn(),
-            uploadProject: vi.fn(),
+            uploadProject: vi.fn().mockResolvedValue({}),
             sendDevServerMessage: vi.fn(),
+            projectData: {
+                name: 'test-project',
+                id: 123,
+                latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                deployedBuild: { id: 'build-1', status: 'SUCCESS' },
+            },
+            targetProjectAccountId: 456,
+            targetTestingAccountId: 789,
         };
         // Mock WebSocketServer constructor
         WebSocketServer.mockImplementation(() => mockWebSocketServer);
@@ -225,23 +233,6 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocket3.close).not.toHaveBeenCalled();
         });
         it('should send project data to each connection independently', () => {
-            // Setup mock project data properties as getters
-            Object.defineProperty(mockLocalDevProcess, 'projectName', {
-                get: () => 'test-project',
-                configurable: true,
-            });
-            Object.defineProperty(mockLocalDevProcess, 'projectId', {
-                get: () => 123,
-                configurable: true,
-            });
-            Object.defineProperty(mockLocalDevProcess, 'targetProjectAccountId', {
-                get: () => 456,
-                configurable: true,
-            });
-            Object.defineProperty(mockLocalDevProcess, 'targetTestingAccountId', {
-                get: () => 789,
-                configurable: true,
-            });
             // Establish multiple connections
             connectionCallback(mockWebSocket1, {
                 headers: { origin: 'https://app.hubspot.com' },
@@ -255,6 +246,8 @@ describe('LocalDevWebsocketServer', () => {
                 data: {
                     projectName: 'test-project',
                     projectId: 123,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
                     targetProjectAccountId: 456,
                     targetTestingAccountId: 789,
                 },
@@ -264,6 +257,8 @@ describe('LocalDevWebsocketServer', () => {
                 data: {
                     projectName: 'test-project',
                     projectId: 123,
+                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
+                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
                     targetProjectAccountId: 456,
                     targetTestingAccountId: 789,
                 },
@@ -284,11 +279,11 @@ describe('LocalDevWebsocketServer', () => {
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(3); // projectNodes and appData listeners
-            expect(closeCallbacks2).toHaveLength(3); // projectNodes and appData listeners
+            expect(closeCallbacks1).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
+            expect(closeCallbacks2).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
             // Simulate first connection closing (call all close callbacks)
             closeCallbacks1.forEach(callback => callback());
-            // Should have removed listeners for first connection (2 listeners: projectNodes and appData)
+            // Should have removed listeners for first connection (3 listeners: projectNodes, appData, and uploadWarnings)
             expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
             // Simulate second connection closing
             closeCallbacks2.forEach(callback => callback());

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

@@ -126,9 +126,9 @@ describe('lib/projects/deploy', () => {
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue(mockDeployResult);
-            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
             expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
-            expect(result).toEqual(mockDeployResult);
+            expect(deploy).toEqual(mockDeployResult);
         });
         it('handles blocked deploy with warnings', async () => {
             const mockBlockedResponse = {
@@ -150,15 +150,80 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
-            expect(result).toBeUndefined();
+        });
+        it('handles blocked deploy with errors (cannot be forced)', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [
+                            {
+                                message: 'This is an error',
+                                isWarning: false,
+                            },
+                        ],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, 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'));
+        });
+        it('handles blocked deploy with no blocking messages', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, 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 result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, 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);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
-            expect(result).toBeUndefined();
+            expect(deploy).toBeUndefined();
+        });
+        it('passes correct parameters to deployProject', async () => {
+            const mockDeployResponseData = {
+                id: 'deploy-123',
+                buildResultType: 'DEPLOY_QUEUED',
+                links: {
+                    status: 'http://status-url',
+                },
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockDeployResponseData,
+            });
+            mockPollDeployStatus.mockResolvedValue({});
+            await handleProjectDeploy(targetAccountId, projectName, buildId, false, true);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV3Api
+            true // force
+            );
         });
     });
 });