@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

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

@@ -0,0 +1,343 @@
+import fs from 'fs';
+import { v2AddComponent } from '../v2AddComponent.js';
+import { getConfigForPlatformVersion } from '../../create/legacy.js';
+import { createV2App } from '../../create/v2.js';
+import { confirmPrompt } from '../../../prompts/promptUtils.js';
+import { projectAddPromptV2 } from '../../../prompts/projectAddPrompt.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+import { trackCommandUsage } from '../../../usageTracking.js';
+import { updateHsMetaFilesWithAutoGeneratedFields } from '../../components.js';
+import { commands } from '../../../../lang/en.js';
+vi.mock('fs');
+vi.mock('../../../prompts/promptUtils');
+vi.mock('../../create/legacy');
+vi.mock('../../create/v2');
+vi.mock('../../../prompts/projectAddPrompt');
+vi.mock('@hubspot/local-dev-lib/github');
+vi.mock('../../../ui/SpinniesManager.js');
+vi.mock('@hubspot/project-parsing-lib/projects');
+vi.mock('../../components.js');
+const mockedFs = vi.mocked(fs);
+const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
+const mockedConfirmPrompt = vi.mocked(confirmPrompt);
+const mockedCreateV2App = vi.mocked(createV2App);
+const mockedProjectAddPromptV2 = vi.mocked(projectAddPromptV2);
+const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
+const mockedGetProjectMetadata = vi.mocked(getProjectMetadata);
+const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
+const mockedUpdateHsMetaFilesWithAutoGeneratedFields = vi.mocked(updateHsMetaFilesWithAutoGeneratedFields);
+describe('lib/projects/add/v2AddComponent', () => {
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: '2025.2',
+    };
+    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(() => {
+        mockedCreateV2App.mockResolvedValue({
+            authType: 'oauth',
+            distribution: 'private',
+        });
+        mockedTrackCommandUsage.mockResolvedValue();
+    });
+    describe('v2AddComponent()', () => {
+        it('successfully adds a component when app already exists', async () => {
+            const mockAppMeta = {
+                name: 'Test App',
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            const mockUpdatedProjectMetadata = {
+                hsMetaFiles: ['/path/to/new-module.meta.json'],
+                components: {
+                    app: {
+                        count: 1,
+                        maxCount: 1,
+                        hsMetaFiles: ['/path/to/app.meta.json'],
+                    },
+                    module: {
+                        count: 1,
+                        maxCount: 5,
+                        hsMetaFiles: ['/path/to/new-module.meta.json'],
+                    },
+                },
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata
+                .mockResolvedValueOnce(mockProjectMetadata)
+                .mockResolvedValueOnce(mockUpdatedProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            mockedUpdateHsMetaFilesWithAutoGeneratedFields.mockResolvedValue(undefined);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('2025.2');
+            expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
+            expect(mockedGetProjectMetadata).toHaveBeenCalledTimes(2);
+            expect(mockedProjectAddPromptV2).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
+                sourceDir: ['2025.2/test-component'],
+                hideLogs: true,
+                branch: 'main',
+            }));
+            expect(mockedUpdateHsMetaFilesWithAutoGeneratedFields).toHaveBeenCalledWith('test-project', ['/path/to/new-module.meta.json'], [], expect.objectContaining({
+                currentProjectMetadata: mockProjectMetadata,
+                updatedProjectMetadata: mockUpdatedProjectMetadata,
+                showSuccessMessage: true,
+            }));
+        });
+        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);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedCreateV2App).toHaveBeenCalled();
+            expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
+                type: 'module',
+            }, mockAccountId);
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
+                sourceDir: ['2025.2/test-component', '2025.2/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);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedCreateV2App).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(v2AddComponent(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(v2AddComponent(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(v2AddComponent(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));
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            await expect(v2AddComponent(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));
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v2AddComponent(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);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            await v2AddComponent(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));
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v2AddComponent(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));
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await v2AddComponent(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(projectConfig.name));
+    }
+    catch (error) {
+        throw new Error(commands.project.add.error.failedToDownloadComponent);
+    }
+}

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

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

package/lib/projects/add/v2AddComponent.js

@@ -0,0 +1,111 @@
+import { commands, lib } from '../../../lang/en.js';
+import { getConfigForPlatformVersion } from '../create/legacy.js';
+import { calculateComponentTemplateChoices, createV2App, } from '../create/v2.js';
+import { PROJECT_WITH_APP } from '../../constants.js';
+import path from 'path';
+import fs from 'fs';
+import { projectAddPromptV2 } from '../../prompts/projectAddPrompt.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, DEFAULT_PROJECT_TEMPLATE_BRANCH, } from '../../constants.js';
+import { updateHsMetaFilesWithAutoGeneratedFields, handleComponentCollision, } from '../components.js';
+import { getProjectMetadata, } from '@hubspot/project-parsing-lib/projects';
+import { APP_KEY as AppKey } from '@hubspot/project-parsing-lib/constants';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { debugError } from '../../errorHandlers/index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { trackCommandUsage } from '../../usageTracking.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+export async function v2AddComponent(args, projectDir, projectConfig, accountId) {
+    const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
+    const { components, parentComponents } = config;
+    if (!components || !components.length) {
+        throw new Error(commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectSrcDirectory = path.join(projectDir, projectConfig.srcDir);
+    const currentProjectMetadata = await getProjectMetadata(projectSrcDirectory);
+    let derivedAuthType;
+    let derivedDistribution;
+    const appsMetadata = currentProjectMetadata.components[AppKey];
+    const shouldCreateApp = appsMetadata.count === 0;
+    if (shouldCreateApp) {
+        const { authType, distribution } = await createV2App(args.auth, args.distribution);
+        derivedDistribution = distribution;
+        derivedAuthType = authType;
+    }
+    else if (appsMetadata.count > appsMetadata.maxCount) {
+        throw new Error(lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
+    }
+    else {
+        const apps = appsMetadata.hsMetaFiles.map(appLoc => {
+            try {
+                return JSON.parse(fs.readFileSync(appLoc, 'utf8'));
+            }
+            catch (err) {
+                throw new Error(lib.projects.create.errors.unableToParseAppConfig(appLoc));
+            }
+        });
+        derivedDistribution = apps[0].config?.distribution;
+        derivedAuthType = apps[0].config?.auth?.type;
+    }
+    const componentTemplateChoices = await calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, args.derivedAccountId, currentProjectMetadata);
+    const projectAddPromptResponse = await projectAddPromptV2(componentTemplateChoices, args.features);
+    const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.cliSelector || componentTemplate.type);
+    await trackCommandUsage('project-add', {
+        type: componentTypes?.join(','),
+    }, accountId);
+    SpinniesManager.add('project-add', {
+        text: commands.project.add.creatingComponent(projectConfig.name),
+    });
+    try {
+        const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
+            return path.join(projectConfig.platformVersion, componentTemplate.path);
+        }) || [];
+        if (shouldCreateApp) {
+            const parentComponent = parentComponents?.find(possibleParent => {
+                return (possibleParent.type === PROJECT_WITH_APP &&
+                    possibleParent.authType === derivedAuthType &&
+                    possibleParent.distribution === derivedDistribution);
+            });
+            if (parentComponent) {
+                components.push(path.join(projectConfig.platformVersion, parentComponent.path));
+            }
+        }
+        if (components.length === 0) {
+            uiLogger.log(lib.projects.add.nothingAdded);
+            return;
+        }
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
+            sourceDir: components,
+            hideLogs: true,
+            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 '';
+            }
+        });
+        SpinniesManager.succeed('project-add', {
+            text: commands.project.add.success(projectConfig.name),
+        });
+        await updateHsMetaFilesWithAutoGeneratedFields(projectConfig.name, newHsMetaFiles, existingUids, {
+            currentProjectMetadata,
+            updatedProjectMetadata,
+            showSuccessMessage: true,
+        });
+    }
+    catch (error) {
+        SpinniesManager.fail('project-add', {
+            text: commands.project.add.failure(projectConfig.name),
+        });
+        debugError(error);
+        throw new Error(commands.project.add.error.failedToDownloadComponent, {
+            cause: error,
+        });
+    }
+}

package/lib/projects/components.d.ts

@@ -0,0 +1,16 @@
+import { Collision } from '@hubspot/local-dev-lib/types/Archive';
+import type { ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+export interface ComponentInfo {
+    filename?: string;
+    isNew: boolean;
+}
+export type ComponentsByType = Map<string, ComponentInfo[]>;
+export declare function buildProjectTree(projectName: string, uids: string[], componentsByType: ComponentsByType, showOnlyNew: boolean): string;
+export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
+export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[], options?: {
+    currentProjectMetadata?: ProjectMetadata;
+    updatedProjectMetadata?: ProjectMetadata;
+    showSuccessMessage?: boolean;
+    isProjectEmpty?: boolean;
+    projectDest?: string;
+}): Promise<void>;