@hubspot/cli 7.7.0-experimental.2 → 7.7.0

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

@@ -0,0 +1,247 @@
+import { legacyAddComponent } from '../legacyAddComponent.js';
+import { findProjectComponents } from '../../structure.js';
+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');
+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 () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedFindProjectComponents).toHaveBeenCalledWith(projectDir);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), '/path/to/project/src/new-component', expect.objectContaining({
+                sourceDir: 'template-path',
+                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'));
+        });
+        it('throws an error when project contains a public app', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PublicApp,
+                    config: {
+                        name: 'public-app',
+                        uid: '',
+                        description: '',
+                        allowedUrls: [],
+                        auth: {
+                            redirectUrls: [],
+                            requiredScopes: [],
+                            optionalScopes: [],
+                            conditionallyRequiredScopes: [],
+                        },
+                        support: {
+                            supportEmail: '',
+                            documentationUrl: '',
+                            supportUrl: '',
+                            supportPhone: '',
+                        },
+                    },
+                    runnable: true,
+                    path: '/path/to/public-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            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();
+        });
+        it('continues when findProjectComponents throws an error', async () => {
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockRejectedValue(new Error('Find components error'));
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalled();
+        });
+        it('throws an error when component list is empty', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue([]);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when component list is null', async () => {
+            const mockComponents = [
+                {
+                    type: ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            // @ts-expect-error Breaking stuff on purpose
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(null);
+            await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when cloning fails', 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: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            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.d.ts

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

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

@@ -0,0 +1,319 @@
+import fs from 'fs';
+import { v3AddComponent } from '../v3AddComponent.js';
+import { getConfigForPlatformVersion } from '../../create/legacy.js';
+import { createV3App } from '../../create/v3.js';
+import { confirmPrompt } from '../../../prompts/promptUtils.js';
+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');
+vi.mock('../../create/legacy');
+vi.mock('../../create/v3');
+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);
+const mockedCreateV3App = vi.mocked(createV3App);
+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',
+        derivedAccountId: 1234,
+    };
+    const projectDir = '/path/to/project';
+    const mockAccountId = 123;
+    const mockComponentTemplate = {
+        label: 'Test Component',
+        path: 'test-component',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockParentComponent = {
+        label: 'Test App',
+        type: 'app',
+        authType: 'oauth',
+        distribution: 'private',
+        path: 'app-template',
+    };
+    const mockConfig = {
+        components: [mockComponentTemplate],
+        parentComponents: [mockParentComponent],
+    };
+    const mockProjectMetadata = {
+        hsMetaFiles: [],
+        components: {
+            app: { count: 1, maxCount: 1, hsMetaFiles: ['/path/to/app.meta.json'] },
+            module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+        },
+    };
+    beforeEach(() => {
+        mockedCreateV3App.mockResolvedValue({
+            authType: 'oauth',
+            distribution: 'private',
+        });
+        mockedTrackCommandUsage.mockResolvedValue();
+    });
+    describe('v3AddComponent()', () => {
+        it('successfully adds a component when app already exists', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            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(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,
+                branch: 'main',
+            }));
+            expect(mockedLogger.success).toHaveBeenCalled();
+        });
+        it('creates an app when no app exists and user confirms', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: { count: 0, maxCount: 1, hsMetaFiles: [] },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            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'],
+            }));
+        });
+        it('should not call clone', 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);
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            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 () => {
+            const mockProjectMetadataMaxApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: { count: 2, maxCount: 1, hsMetaFiles: [] },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataMaxApps);
+            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 = {
+                components: [],
+                parentComponents: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
+            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);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockImplementation(() => {
+                throw new Error('File read error');
+            });
+            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
+        });
+        it('throws an error when cloning fails', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            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

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

package/lib/projects/add/legacyAddComponent.js

@@ -0,0 +1,46 @@
+import { ComponentTypes } from '../../../types/Projects.js';
+import { findProjectComponents } from '../structure.js';
+import { debugError } from '../../errorHandlers/index.js';
+import { commands } from '../../../lang/en.js';
+import { getProjectComponentListFromRepo } from '../create/legacy.js';
+import { projectAddPrompt } from '../../prompts/projectAddPrompt.js';
+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';
+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 {
+        const components = await findProjectComponents(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === ComponentTypes.PublicApp);
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (projectContainsPublicApp) {
+        throw new Error(commands.project.add.error.projectContainsPublicApp);
+    }
+    uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
+    const components = await getProjectComponentListFromRepo(projectConfig.platformVersion);
+    if (!components || !components.length) {
+        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, {
+            sourceDir: projectAddPromptResponse.componentTemplate.path,
+            branch: DEFAULT_PROJECT_TEMPLATE_BRANCH,
+            hideLogs: true,
+        });
+        uiLogger.success(commands.project.add.success(projectAddPromptResponse.name));
+    }
+    catch (error) {
+        throw new Error(commands.project.add.error.failedToDownloadComponent);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ProjectConfig } from '../../../types/Projects.js';
+export declare function v3AddComponent(args: {
+    name?: string;
+    type?: string;
+    features?: string[];
+    auth?: string;
+    distribution?: string;
+    derivedAccountId: number;
+}, projectDir: string, projectConfig: ProjectConfig, accountId: number): Promise<void>;