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

package/lib/app/migrate.js

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

package/lib/constants.d.ts

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

package/lib/constants.js

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

package/lib/errorHandlers/index.d.ts

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

package/lib/errorHandlers/index.js

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

package/lib/hasFeature.js

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

package/lib/importData.js

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

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

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

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

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

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

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

package/lib/projects/__tests__/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>;