@hubspot/cli 7.7.32-experimental.0 → 7.7.34-experimental.0

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

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

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__/platformVersion.test.d.ts

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

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);

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

@@ -4,6 +4,7 @@ import { getProjectComponentListFromRepo } from '../../create/legacy.js';
 import { projectAddPrompt } from '../../../prompts/projectAddPrompt.js';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { trackCommandUsage } from '../../../usageTracking.js';
 import { ComponentTypes, } from '../../../../types/Projects.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('../../structure');
@@ -11,21 +12,25 @@ vi.mock('../../create/legacy');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/logger');
 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 mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/legacyAddComponent', () => {
     const mockProjectConfig = {
         name: 'test-project',
         srcDir: 'src',
         platformVersion: 'v1',
     };
+    const accountId = 1234567890;
     const mockArgs = { name: 'test-component', type: 'module' };
     const projectDir = '/path/to/project';
     beforeEach(() => {
         vi.resetAllMocks();
+        mockedTrackCommandUsage.mockResolvedValue();
     });
     describe('legacyAddComponent()', () => {
         it('successfully adds a component to a project without public apps', async () => {
@@ -58,7 +63,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
             mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
             expect(mockedFindProjectComponents).toHaveBeenCalledWith(projectDir);
             expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
             expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
@@ -67,6 +72,9 @@ describe('lib/projects/add/legacyAddComponent', () => {
                 branch: 'main',
                 hideLogs: true,
             }));
+            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'));
         });
@@ -97,7 +105,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
                 },
             ];
             mockedFindProjectComponents.mockResolvedValue(mockComponents);
-            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.projectContainsPublicApp);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.projectContainsPublicApp);
             expect(mockedGetProjectComponentListFromRepo).not.toHaveBeenCalled();
             expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
@@ -118,7 +126,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
             mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
             expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
             expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
             expect(mockedCloneGithubRepo).toHaveBeenCalled();
@@ -140,7 +148,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             ];
             mockedFindProjectComponents.mockResolvedValue(mockComponents);
             mockedGetProjectComponentListFromRepo.mockResolvedValue([]);
-            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
             expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
         });
@@ -162,7 +170,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedFindProjectComponents.mockResolvedValue(mockComponents);
             // @ts-expect-error Breaking stuff on purpose
             mockedGetProjectComponentListFromRepo.mockResolvedValue(null);
-            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
             expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
         });
@@ -196,9 +204,44 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
             mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
-            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
             expect(mockedCloneGithubRepo).toHaveBeenCalled();
             expect(mockedLogger.success).not.toHaveBeenCalled();
         });
+        it('calls trackCommandUsage with correct component type', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Card Component', path: 'card-component', type: 'card' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-card',
+                componentTemplate: {
+                    label: 'Card Component',
+                    path: 'card-template-path',
+                    type: 'card',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'card',
+            }, accountId);
+        });
     });
 });

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

@@ -33,7 +33,11 @@ describe('lib/projects/add/v3AddComponent', () => {
         srcDir: 'src',
         platformVersion: 'v3',
     };
-    const mockArgs = { name: 'test-component', type: 'module' };
+    const mockArgs = {
+        name: 'test-component',
+        type: 'module',
+        derivedAccountId: 1234,
+    };
     const projectDir = '/path/to/project';
     const mockAccountId = 123;
     const mockComponentTemplate = {
@@ -245,5 +249,71 @@ describe('lib/projects/add/v3AddComponent', () => {
                 type: '',
             }, mockAccountId);
         });
+        it('should track usage with cliSelector when available', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockComponentTemplateWithCliSelector = {
+                label: 'Workflow Action Tool',
+                path: 'workflow-action-tool',
+                type: 'workflow-action',
+                cliSelector: 'workflow-action-tool',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplateWithCliSelector],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'workflow-action-tool',
+            }, mockAccountId);
+        });
+        it('should track usage with cliSelector for multiple components', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockComponentWithCliSelector = {
+                label: 'Workflow Action Tool',
+                path: 'workflow-action-tool',
+                type: 'workflow-action',
+                cliSelector: 'workflow-action-tool',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockComponentWithoutCliSelector = {
+                label: 'Regular Module',
+                path: 'module',
+                type: 'module',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockPromptResponse = {
+                componentTemplate: [
+                    mockComponentWithCliSelector,
+                    mockComponentWithoutCliSelector,
+                ],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'workflow-action-tool,module',
+            }, mockAccountId);
+        });
     });
 });

package/lib/projects/add/legacyAddComponent.d.ts

@@ -2,4 +2,4 @@ import { ProjectConfig } from '../../../types/Projects.js';
 export declare function legacyAddComponent(args: {
     name?: string;
     type?: string;
-}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;
+}, projectDir: string, projectConfig: ProjectConfig, derivedAccountId: number): Promise<void>;

package/lib/projects/add/legacyAddComponent.js

@@ -8,7 +8,8 @@ import path from 'path';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { uiLogger } from '../../ui/logger.js';
-export async function legacyAddComponent(args, projectDir, projectConfig) {
+import { trackCommandUsage } from '../../usageTracking.js';
+export async function legacyAddComponent(args, projectDir, projectConfig, derivedAccountId) {
     // We currently only support adding private apps to projects
     let projectContainsPublicApp = false;
     try {
@@ -27,6 +28,9 @@ export async function legacyAddComponent(args, projectDir, projectConfig) {
         throw new Error(commands.project.add.error.failedToFetchComponentList);
     }
     const projectAddPromptResponse = await projectAddPrompt(components, args);
+    trackCommandUsage('project-add', {
+        type: projectAddPromptResponse.componentTemplate.type,
+    }, derivedAccountId);
     try {
         const componentPath = path.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
         await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {

package/lib/projects/add/v3AddComponent.d.ts

@@ -5,4 +5,5 @@ export declare function v3AddComponent(args: {
     features?: string[];
     auth?: string;
     distribution?: string;
+    derivedAccountId: number;
 }, projectDir: string, projectConfig: ProjectConfig, accountId: number): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -46,9 +46,9 @@ export async function v3AddComponent(args, projectDir, projectConfig, accountId)
         derivedDistribution = apps[0].config?.distribution;
         derivedAuthType = apps[0].config?.auth?.type;
     }
-    const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, currentProjectMetadata);
+    const componentTemplateChoices = await calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, args.derivedAccountId, currentProjectMetadata);
     const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
-    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.type);
+    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.cliSelector || componentTemplate.type);
     await trackCommandUsage('project-add', {
         type: componentTypes?.join(','),
     }, accountId);

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

@@ -26,9 +26,9 @@ describe('lib/projects/create/v3', () => {
                 card: { count: 3, maxCount: 3, hsMetaFiles: [] },
             },
         };
-        it('returns enabled components when they meet all requirements', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', mockProjectMetadataForChoices);
-            expect(choices).toHaveLength(3); // includes separator
+        it('returns enabled components when they meet all requirements', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', 123, mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(4); // includes separator
             expect(choices[0]).toEqual({
                 name: 'Module Component',
                 value: mockComponents[0],
@@ -39,8 +39,8 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('maximum'),
             });
         });
-        it('disables components when auth type is not supported', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', mockProjectMetadataForChoices);
+        it('disables components when auth type is not supported', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', 123, mockProjectMetadataForChoices);
             // All components should be disabled, so they come after the separator
             expect(choices[1]).toEqual({
                 name: expect.stringContaining('Module Component'),
@@ -48,8 +48,8 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('privatekey'),
             });
         });
-        it('disables components when distribution is not supported', () => {
-            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', mockProjectMetadataForChoices);
+        it('disables components when distribution is not supported', async () => {
+            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', 123, mockProjectMetadataForChoices);
             // All components should be disabled, so they come after the separator
             expect(choices[1]).toEqual({
                 name: expect.stringContaining('Module Component'),
@@ -57,7 +57,7 @@ describe('lib/projects/create/v3', () => {
                 disabled: expect.stringContaining('enterprise'),
             });
         });
-        it('handles components without auth type or distribution restrictions', () => {
+        it('handles components without auth type or distribution restrictions', async () => {
             const componentsWithoutRestrictions = [
                 {
                     label: 'Unrestricted Component',
@@ -65,7 +65,7 @@ describe('lib/projects/create/v3', () => {
                     type: 'module',
                 },
             ];
-            const choices = calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', {
+            const choices = await calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', 123, {
                 hsMetaFiles: [],
                 components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
             });
@@ -74,5 +74,93 @@ describe('lib/projects/create/v3', () => {
                 value: componentsWithoutRestrictions[0],
             });
         });
+        it('handles components with cliSelector field (metadata compatibility)', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataWithWorkflowAction = {
+                hsMetaFiles: [],
+                components: {
+                    'workflow-action': { count: 2, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 213, projectMetadataWithWorkflowAction);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool',
+                value: componentWithCliSelector[0],
+            });
+        });
+        it('disables component when project metadata count exceeds maximum', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataAtMaxWorkflowAction = {
+                hsMetaFiles: [],
+                components: {
+                    'workflow-action': { count: 3, maxCount: 3, hsMetaFiles: [] },
+                },
+            };
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, projectMetadataAtMaxWorkflowAction);
+            expect(choices).toHaveLength(3); // includes separators
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Workflow Action Tool'),
+                value: componentWithCliSelector[0],
+                disabled: expect.stringContaining('maximum'),
+            });
+        });
+        it('handles undefined projectMetadata without throwing errors', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, undefined);
+            expect(choices).toHaveLength(1); // no disabled components
+            expect(choices[0]).toEqual({
+                name: 'Workflow Action Tool',
+                value: componentWithCliSelector[0],
+            });
+        });
+        it('handles projectMetadata with undefined components property (after fix)', async () => {
+            const componentWithCliSelector = [
+                {
+                    label: 'Workflow Action Tool',
+                    path: 'workflow-action-tool',
+                    type: 'workflow-action',
+                    cliSelector: 'workflow-action-tool',
+                    supportedAuthTypes: ['oauth'],
+                    supportedDistributions: ['private'],
+                },
+            ];
+            const projectMetadataWithoutComponents = {
+                hsMetaFiles: [],
+                components: undefined,
+            };
+            // This test verifies the null check fix works
+            // Currently this will fail because the fix checks for projectMetadata.components
+            await expect(async () => calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, 
+            // @ts-expect-error breaking stuff on purpose
+            projectMetadataWithoutComponents)).rejects.toThrow();
+        });
     });
 });

package/lib/projects/create/index.js

@@ -1,7 +1,7 @@
 import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
-import { useV3Api } from '../buildAndDeploy.js';
+import { useV3Api } from '../platformVersion.js';
 import { v3ComponentFlow } from './v3.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { uiLogger } from '../../ui/logger.js';
@@ -12,7 +12,7 @@ export async function handleProjectCreationFlow(args) {
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
     if (useV3Api(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution);
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
         const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {
             authType,

package/lib/projects/create/legacy.js

@@ -3,7 +3,7 @@ import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
-import { useV3Api } from '../buildAndDeploy.js';
+import { useV3Api } from '../platformVersion.js';
 import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';

package/lib/projects/create/v3.d.ts

@@ -6,7 +6,7 @@ export declare function createV3App(providedAuth: string | undefined, providedDi
     authType: string;
     distribution: string;
 }>;
-export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): (ComponentTemplateChoice | Separator)[];
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
 type V3ComponentInfo = {
     authType?: string;
     distribution?: string;
@@ -14,7 +14,7 @@ type V3ComponentInfo = {
     projectContents?: string;
     componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
 };
-export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V3ComponentInfo>;
 export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
     selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
     platformVersion: string;