@hubspot/cli 7.6.0-beta.11 → 7.6.0-beta.13

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

@@ -7,6 +7,7 @@ import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { trackCommandUsage } from '../../../usageTracking.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
@@ -16,6 +17,7 @@ vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
+vi.mock('../../../usageTracking');
 const mockedFs = vi.mocked(fs);
 const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
 const mockedConfirmPrompt = vi.mocked(confirmPrompt);
@@ -24,14 +26,20 @@ const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
 const mockedLogger = vi.mocked(logger);
 const mockedGetProjectMetadata = vi.mocked(getProjectMetadata);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/v3AddComponent', () => {
     const mockProjectConfig = {
         name: 'test-project',
         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 = {
         label: 'Test Component',
         path: 'test-component',
@@ -62,6 +70,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             authType: 'oauth',
             distribution: 'private',
         });
+        mockedTrackCommandUsage.mockResolvedValue();
     });
     describe('v3AddComponent()', () => {
         it('successfully adds a component when app already exists', async () => {
@@ -79,10 +88,13 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('v3');
             expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
             expect(mockedProjectAddPromptV3).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component'],
                 hideLogs: true,
@@ -106,8 +118,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
                 sourceDir: ['v3/test-component', 'v3/app-template'],
             }));
@@ -132,8 +147,11 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedCreateV3App).not.toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: '',
+            }, mockAccountId);
             expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
         });
         it('throws an error when app count exceeds maximum', async () => {
@@ -146,7 +164,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataMaxApps);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('This project currently has the maximum number of apps: 1');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('This project currently has the maximum number of apps: 1');
         });
         it('throws an error when components list is empty', async () => {
             const mockEmptyConfig = {
@@ -154,7 +172,7 @@ describe('lib/projects/add/v3AddComponent', () => {
                 parentComponents: [],
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
         });
         it('throws an error when app meta file cannot be parsed', async () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
@@ -162,7 +180,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockImplementation(() => {
                 throw new Error('File read error');
             });
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('Unable to parse app file');
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
         });
         it('throws an error when cloning fails', async () => {
             const mockAppMeta = {
@@ -179,7 +197,123 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
             mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+        });
+        it('should track usage with multiple component types', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockSecondComponentTemplate = {
+                label: 'Test Card',
+                path: 'test-card',
+                type: 'card',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate, mockSecondComponentTemplate],
+            };
+            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: 'module,card',
+            }, mockAccountId);
+        });
+        it('should track usage with empty type when no components are selected', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: {
+                        count: 1,
+                        maxCount: 1,
+                        hsMetaFiles: ['/path/to/app.meta.json'],
+                    },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                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;
-}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;
+    derivedAccountId: number;
+}, projectDir: string, projectConfig: ProjectConfig, accountId: number): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -6,13 +6,14 @@ import path from 'path';
 import fs from 'fs';
 import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
 import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
-import { handleComponentCollision } from '../components.js';
+import { updateHsMetaFilesWithAutoGeneratedFields, handleComponentCollision, } from '../components.js';
 import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { debugError } from '../../errorHandlers/index.js';
 import { uiLogger } from '../../ui/logger.js';
-export async function v3AddComponent(args, projectDir, projectConfig) {
+import { trackCommandUsage } from '../../usageTracking.js';
+export async function v3AddComponent(args, projectDir, projectConfig, accountId) {
     uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
     const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
@@ -20,10 +21,10 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
         throw new Error(commands.project.add.error.failedToFetchComponentList);
     }
     const projectSrcDirectory = path.join(projectDir, projectConfig.srcDir);
-    const projectMetadata = await getProjectMetadata(projectSrcDirectory);
+    const currentProjectMetadata = await getProjectMetadata(projectSrcDirectory);
     let derivedAuthType;
     let derivedDistribution;
-    const appsMetadata = projectMetadata.components[AppKey];
+    const appsMetadata = currentProjectMetadata.components[AppKey];
     const shouldCreateApp = appsMetadata.count === 0;
     if (shouldCreateApp) {
         const { authType, distribution } = await createV3App(args.auth, args.distribution);
@@ -45,8 +46,12 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
         derivedDistribution = apps[0].config?.distribution;
         derivedAuthType = apps[0].config?.auth?.type;
     }
-    const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const componentTemplateChoices = await calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, args.derivedAccountId, currentProjectMetadata);
     const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
+    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.cliSelector || componentTemplate.type);
+    await trackCommandUsage('project-add', {
+        type: componentTypes?.join(','),
+    }, accountId);
     try {
         const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
             return path.join(projectConfig.platformVersion, componentTemplate.path);
@@ -71,6 +76,18 @@ export async function v3AddComponent(args, projectDir, projectConfig) {
             branch: DEFAULT_PROJECT_TEMPLATE_BRANCH,
             handleCollision: handleComponentCollision,
         });
+        const updatedProjectMetadata = await getProjectMetadata(projectSrcDirectory);
+        const newHsMetaFiles = updatedProjectMetadata.hsMetaFiles.filter(hsMetaFile => !currentProjectMetadata.hsMetaFiles.includes(hsMetaFile));
+        const existingUids = currentProjectMetadata.hsMetaFiles.map(hsMetaFile => {
+            try {
+                const { uid } = JSON.parse(fs.readFileSync(hsMetaFile, 'utf8'));
+                return uid;
+            }
+            catch (err) {
+                return '';
+            }
+        });
+        updateHsMetaFilesWithAutoGeneratedFields(projectConfig.name, newHsMetaFiles, existingUids);
         uiLogger.success(commands.project.add.success(projectAddPromptResponse.componentTemplate
             .map(template => `'${template.label}'`)
             .join(', '), projectAddPromptResponse.componentTemplate.length > 1));

package/lib/projects/components.d.ts

@@ -1,2 +1,3 @@
 import { Collision } from '@hubspot/local-dev-lib/types/Archive';
 export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
+export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[]): void;

package/lib/projects/components.js

@@ -1,6 +1,9 @@
 import path from 'path';
 import fs from 'fs';
-import { metafileExtension } from '@hubspot/project-parsing-lib';
+import { coerceToValidUid, metafileExtension, } from '@hubspot/project-parsing-lib';
+import { uiLogger } from '../ui/logger.js';
+import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+import { lib } from '../../lang/en.js';
 // Handles a collision between component source files
 export function handleComponentCollision({ dest, src, collisions }) {
     const hsMetaFiles = [];
@@ -74,3 +77,26 @@ function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
         fs.writeFileSync(path.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
     });
 }
+export function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids = []) {
+    uiLogger.log('');
+    uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.header);
+    for (const hsMetaFile of hsMetaFilePaths) {
+        const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
+        let uid = coerceToValidUid(`${component.type}-${projectName}`) || component.uid;
+        if (existingUids.includes(uid)) {
+            uid =
+                coerceToValidUid(`${component.type}-${Date.now()}-${projectName}`) ||
+                    component.uid;
+        }
+        component.uid = uid;
+        if (component.type === AppKey && component.config) {
+            component.config.name = `${projectName}-Application`;
+            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.applicationLog(component.type, component.uid, component.config.name));
+        }
+        else {
+            uiLogger.log(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.componentLog(component.type, component.uid));
+        }
+        fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
+    }
+    uiLogger.log('');
+}