@hubspot/cli 7.10.1-experimental.0 → 7.11.0-beta.0

package/lib/errorHandlers/index.js

@@ -14,13 +14,11 @@ export function logError(error, context) {
     if (shouldSuppressError(error, context)) {
         return;
     }
-    if (isHubSpotHttpError(error) && 'context' in error) {
+    if (isHubSpotHttpError(error)) {
         if (shouldSuppressError(error, error.context)) {
             return;
         }
-    }
-    if (isHubSpotHttpError(error) && context) {
-        error.updateContext(context);
+        error.updateContext(context || {}, lib.errorHandlers.index.additionalDebugContext);
     }
     if (isHubSpotHttpError(error) && isValidationError(error)) {
         uiLogger.error(error.formattedValidationErrors());
@@ -57,9 +55,14 @@ export function debugError(error, context) {
     }
     else {
         uiLogger.debug(lib.errorHandlers.index.errorOccurred(String(error)));
-    }
-    if (error instanceof Error && error.cause && !isHubSpotHttpError(error)) {
-        uiLogger.debug(lib.errorHandlers.index.errorCause(util.inspect(error.cause, false, null, true)));
+        if (error instanceof Error && error.cause) {
+            if (isHubSpotHttpError(error.cause)) {
+                uiLogger.debug(error.cause.toString());
+            }
+            else {
+                uiLogger.debug(lib.errorHandlers.index.errorCause(util.inspect(error.cause, false, null, true)));
+            }
+        }
     }
     if (context) {
         uiLogger.debug(lib.errorHandlers.index.errorContext(util.inspect(context, false, null, true)));

package/lib/projectProfiles.d.ts

@@ -2,7 +2,6 @@ import { HsProfileFile } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { ProjectConfig } from '../types/Projects.js';
 export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
-export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | never;
-export declare function enforceProfileUsage(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string | undefined, silent?: boolean): Promise<number | undefined>;
-export declare function validateProjectForProfile(projectConfig: ProjectConfig, projectDir: string, profileName: string, derivedAccountId: number, indentSpinners?: boolean): Promise<(string | Error)[]>;
+export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
+export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -1,12 +1,9 @@
 import path from 'path';
 import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
-import { commands, lib } from '../lang/en.js';
+import { lib } from '../lang/en.js';
 import { uiBetaTag, uiLine } from './ui/index.js';
 import { uiLogger } from './ui/logger.js';
-import { validateProfileVariables } from '@hubspot/project-parsing-lib/src/index.js';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import SpinniesManager from './ui/SpinniesManager.js';
-import { handleTranslate } from './projects/upload.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
 export function logProfileHeader(profileName) {
     uiLine();
     uiBetaTag(lib.projectProfiles.logs.usingProfile(getHsProfileFilename(profileName)));
@@ -26,94 +23,51 @@ export function logProfileFooter(profile, includeVariables = false) {
 }
 export function loadProfile(projectConfig, projectDir, profileName) {
     if (!projectConfig || !projectDir) {
-        throw new Error(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        uiLogger.error(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+        return;
     }
     const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
     const profileFilename = getHsProfileFilename(profileName);
-    let profile;
     try {
-        profile = loadHsProfileFile(projectSourceDir, profileName);
+        const profile = loadHsProfileFile(projectSourceDir, profileName);
+        if (!profile) {
+            uiLogger.error(lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
+            return;
+        }
+        if (!profile.accountId) {
+            uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
+            return;
+        }
+        return profile;
     }
     catch (e) {
-        throw new Error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
-    }
-    if (!profile) {
-        throw new Error(lib.projectProfiles.loadProfile.errors.profileNotFound(profileFilename));
-    }
-    if (!profile.accountId) {
-        throw new Error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
-    }
-    try {
-        getConfigAccountById(profile.accountId);
-    }
-    catch (error) {
-        throw new Error(lib.projectProfiles.loadProfile.errors.listedAccountNotFound(profile.accountId, profileFilename));
+        uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
+        return;
     }
-    return profile;
 }
-export async function enforceProfileUsage(projectConfig, projectDir) {
+export async function exitIfUsingProfiles(projectConfig, projectDir) {
     if (projectConfig && projectDir) {
         const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
         if (existingProfiles.length > 0) {
-            throw new Error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            uiLogger.error(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            process.exit(EXIT_CODES.ERROR);
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, profileName, silent = false) {
-    if (!profileName) {
-        await enforceProfileUsage(projectConfig, projectDir);
-        return;
-    }
-    if (!silent) {
-        logProfileHeader(profileName);
-    }
-    const profile = loadProfile(projectConfig, projectDir, profileName);
-    if (!silent) {
-        logProfileFooter(profile, true);
-    }
-    if (profile.variables) {
-        const validationResult = validateProfileVariables(profile.variables, profileName);
-        if (!validationResult.success) {
-            throw new Error(lib.projectProfiles.loadProfile.errors.profileNotValid(getHsProfileFilename(profileName), validationResult.errors));
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
+    if (argsProfile) {
+        logProfileHeader(argsProfile);
+        const profile = loadProfile(projectConfig, projectDir, argsProfile);
+        if (!profile) {
+            uiLine();
+            process.exit(EXIT_CODES.ERROR);
         }
+        logProfileFooter(profile, true);
+        return profile.accountId;
     }
-    return profile.accountId;
-    // A profile must be specified if this project has profiles configured
-}
-export async function validateProjectForProfile(projectConfig, projectDir, profileName, derivedAccountId, indentSpinners = false) {
-    let targetAccountId = derivedAccountId;
-    const spinnerName = `validatingProfile-${profileName}`;
-    const profileFilename = getHsProfileFilename(profileName);
-    SpinniesManager.init();
-    SpinniesManager.add(spinnerName, {
-        text: commands.project.validate.spinners.validatingProfile(profileFilename),
-        indent: indentSpinners ? 4 : 0,
-    });
-    try {
-        const accountId = await loadAndValidateProfile(projectConfig, projectDir, profileName, true);
-        targetAccountId = accountId || derivedAccountId;
-    }
-    catch (error) {
-        SpinniesManager.fail(spinnerName, {
-            text: commands.project.validate.spinners.profileValidationFailed(profileFilename),
-        });
-        return [error instanceof Error ? error.message : `${error}`];
-    }
-    try {
-        await handleTranslate(projectDir, projectConfig, targetAccountId, false, profileName);
-    }
-    catch (error) {
-        SpinniesManager.fail(spinnerName, {
-            text: commands.project.validate.spinners.invalidWithProfile(profileFilename, projectConfig.name),
-        });
-        const errors = [
-            commands.project.validate.failure(projectConfig.name),
-        ];
-        errors.push(error instanceof Error ? error : `${error}`);
-        return errors;
+    else {
+        // A profile must be specified if this project has profiles configured
+        await exitIfUsingProfiles(projectConfig, projectDir);
     }
-    SpinniesManager.succeed(spinnerName, {
-        text: commands.project.validate.spinners.profileValidationSucceeded(profileFilename),
-    });
-    return [];
+    return undefined;
 }

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

@@ -13,20 +13,6 @@ vi.mock('@hubspot/project-parsing-lib', () => ({
 vi.mock('@hubspot/project-parsing-lib/src/lib/constants.js', () => ({
     AppKey: 'app',
 }));
-vi.mock('../../../lang/en.js', () => ({
-    lib: {
-        projects: {
-            updateHsMetaFilesWithAutoGeneratedFields: {
-                header: 'Updating component metadata files...',
-                applicationLog: (type, uid, name) => `Updated ${type} component with uid: ${uid} and name: ${name}`,
-                componentLog: (type, uid) => `Updated ${type} component with uid: ${uid}`,
-            },
-            generateSafeFilenameDifferentiator: {
-                failedToCheckFiles: 'Failed to check files for filename differentiator. Falling back to timestamp.',
-            },
-        },
-    },
-}));
 const mockedFs = vi.mocked(fs);
 const mockCoerceToValidUid = vi.mocked(coerceToValidUid);
 const mockedFileExists = vi.mocked(fileExists);
@@ -247,7 +233,6 @@ describe('lib/projects/components', () => {
         });
     });
     describe('updateHsMetaFilesWithAutoGeneratedFields()', () => {
-        const mockUiLogger = vi.mocked(uiLogger);
         beforeEach(() => {
             vi.resetAllMocks();
             mockCoerceToValidUid.mockImplementation((input) => input);
@@ -282,6 +267,8 @@ describe('lib/projects/components', () => {
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
             expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_card');
             expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_function');
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_card');
+            expect(mockCoerceToValidUid).toHaveBeenCalledWith('my-project_function');
             expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
                 type: 'card',
                 uid: 'card_my_project',
@@ -293,9 +280,6 @@ describe('lib/projects/components', () => {
                 type: 'function',
                 uid: 'function_my_project',
             }, null, 2));
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated card component with uid: card_my_project');
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated function component with uid: function_my_project');
         });
         it('handles app components by updating both uid and config.name', () => {
             const projectName = 'test-app';
@@ -321,7 +305,6 @@ describe('lib/projects/components', () => {
                     other: 'property',
                 },
             }, null, 2));
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app_test_app and name: test-app-Application');
         });
         it('handles UID collisions by using differentiators', () => {
             const projectName = 'collision-project';
@@ -366,8 +349,6 @@ describe('lib/projects/components', () => {
             updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
             expect(mockedFs.readFileSync).not.toHaveBeenCalled();
             expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
-            expect(mockUiLogger.log).toHaveBeenCalledWith('');
         });
         it('handles components without config property for app type', () => {
             const projectName = 'no-config-project';
@@ -386,7 +367,6 @@ describe('lib/projects/components', () => {
                 type: 'app',
                 uid: 'app_no_config_project',
             }, null, 2));
-            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app_no_config_project');
         });
         it('replaces hyphens with underscores in coerced UIDs', () => {
             const projectName = 'my-project';

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

@@ -3,7 +3,7 @@ import { validateBuildIdForDeploy, logDeployErrors, handleProjectDeploy, } from
 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 { deployProjectV1, deployProjectV2, } from '@hubspot/local-dev-lib/api/projects';
 import { pollDeployStatus } from '../pollProjectBuildAndDeploy.js';
 // Mock external dependencies
 vi.mock('../../ui/logger.js');
@@ -11,7 +11,8 @@ vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../pollProjectBuildAndDeploy.js');
 const mockUiLogger = vi.mocked(uiLogger);
-const mockDeployProject = vi.mocked(deployProject);
+const mockDeployProjectV1 = vi.mocked(deployProjectV1);
+const mockDeployProjectV2 = vi.mocked(deployProjectV2);
 const mockPollDeployStatus = vi.mocked(pollDeployStatus);
 describe('lib/projects/deploy', () => {
     beforeEach(() => {
@@ -123,12 +124,12 @@ describe('lib/projects/deploy', () => {
                 source: 'HUBSPOT_USER',
                 subdeployStatuses: [],
             };
-            mockDeployProject.mockResolvedValue({
+            mockDeployProjectV2.mockResolvedValue({
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue(mockDeployResult);
             const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV2Api, force);
+            expect(mockDeployProjectV2).toHaveBeenCalledWith(targetAccountId, projectName, buildId, force);
             expect(deploy).toEqual(mockDeployResult);
         });
         it('handles blocked deploy with warnings', async () => {
@@ -148,7 +149,7 @@ describe('lib/projects/deploy', () => {
                     },
                 ],
             };
-            mockDeployProject.mockResolvedValue({
+            mockDeployProjectV2.mockResolvedValue({
                 data: mockBlockedResponse,
             });
             await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
@@ -171,7 +172,7 @@ describe('lib/projects/deploy', () => {
                     },
                 ],
             };
-            mockDeployProject.mockResolvedValue({
+            mockDeployProjectV2.mockResolvedValue({
                 data: mockBlockedResponse,
             });
             await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
@@ -190,7 +191,7 @@ describe('lib/projects/deploy', () => {
                     },
                 ],
             };
-            mockDeployProject.mockResolvedValue({
+            mockDeployProjectV2.mockResolvedValue({
                 data: mockBlockedResponse,
             });
             await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
@@ -198,18 +199,18 @@ describe('lib/projects/deploy', () => {
             expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployIssueComponentGeneric('component-1', 'module'));
         });
         it('handles general deploy failure', async () => {
-            mockDeployProject.mockResolvedValue({ data: null });
+            mockDeployProjectV2.mockResolvedValue({ data: null });
             const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
             expect(deploy).toBeUndefined();
         });
         it('handles undefined deploy response', async () => {
-            mockDeployProject.mockResolvedValue({ data: undefined });
+            mockDeployProjectV2.mockResolvedValue({ data: undefined });
             const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
             expect(deploy).toBeUndefined();
         });
-        it('passes correct parameters to deployProject', async () => {
+        it('passes correct parameters to deployProjectV1', async () => {
             const mockDeployResponseData = {
                 id: 'deploy-123',
                 buildResultType: 'DEPLOY_QUEUED',
@@ -217,14 +218,15 @@ describe('lib/projects/deploy', () => {
                     status: 'http://status-url',
                 },
             };
-            mockDeployProject.mockResolvedValue({
+            mockDeployProjectV1.mockResolvedValue({
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue({});
-            await handleProjectDeploy(targetAccountId, projectName, buildId, false, true);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV2Api
+            await handleProjectDeploy(targetAccountId, projectName, buildId, false, // isV2Project
             true // force
             );
+            expect(mockDeployProjectV1).toHaveBeenCalledWith(targetAccountId, projectName, buildId, true // force
+            );
         });
     });
 });

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

@@ -76,7 +76,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
                 type: 'module',
             }, accountId);
             expect(mockedUiLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
-            expect(mockedUiLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
+            expect(mockedUiLogger.success).toHaveBeenCalledWith(commands.project.add.success('test-project'));
         });
         it('throws an error when project contains a public app', async () => {
             const mockComponents = [

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

@@ -5,9 +5,9 @@ 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 { uiLogger } from '../../../ui/logger.js';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { trackCommandUsage } from '../../../usageTracking.js';
+import { updateHsMetaFilesWithAutoGeneratedFields } from '../../components.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
@@ -16,17 +16,19 @@ vi.mock('../../create/v2');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('../../../ui/logger.js');
+vi.mock('../../../ui/SpinniesManager.js');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
 vi.mock('../../../usageTracking');
+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 mockedUiLogger = vi.mocked(uiLogger);
 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',
@@ -75,6 +77,7 @@ describe('lib/projects/add/v2AddComponent', () => {
     describe('v2AddComponent()', () => {
         it('successfully adds a component when app already exists', async () => {
             const mockAppMeta = {
+                name: 'Test App',
                 config: {
                     distribution: 'private',
                     auth: { type: 'oauth' },
@@ -83,14 +86,33 @@ describe('lib/projects/add/v2AddComponent', () => {
             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.mockResolvedValue(mockProjectMetadata);
+            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',
@@ -100,7 +122,11 @@ describe('lib/projects/add/v2AddComponent', () => {
                 hideLogs: true,
                 branch: 'main',
             }));
-            expect(mockedUiLogger.success).toHaveBeenCalled();
+            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 = {

package/lib/projects/add/legacyAddComponent.js

@@ -38,7 +38,7 @@ export async function legacyAddComponent(args, projectDir, projectConfig, derive
             branch: DEFAULT_PROJECT_TEMPLATE_BRANCH,
             hideLogs: true,
         });
-        uiLogger.success(commands.project.add.success(projectAddPromptResponse.name));
+        uiLogger.success(commands.project.add.success(projectConfig.name));
     }
     catch (error) {
         throw new Error(commands.project.add.error.failedToDownloadComponent);

package/lib/projects/add/v2AddComponent.js

@@ -13,8 +13,8 @@ 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) {
-    uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
     const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
     if (!components || !components.length) {
@@ -52,6 +52,10 @@ export async function v2AddComponent(args, projectDir, projectConfig, accountId)
     await trackCommandUsage('project-add', {
         type: componentTypes?.join(','),
     }, accountId);
+    SpinniesManager.init();
+    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);
@@ -87,12 +91,19 @@ export async function v2AddComponent(args, projectDir, projectConfig, accountId)
                 return '';
             }
         });
-        updateHsMetaFilesWithAutoGeneratedFields(projectConfig.name, newHsMetaFiles, existingUids);
-        uiLogger.success(commands.project.add.success(projectAddPromptResponse.componentTemplate
-            .map(template => `'${template.label}'`)
-            .join(', '), projectAddPromptResponse.componentTemplate.length > 1));
+        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

@@ -1,3 +1,10 @@
 import { Collision } from '@hubspot/local-dev-lib/types/Archive';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;
-export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[]): void;
+export declare function updateHsMetaFilesWithAutoGeneratedFields(projectName: string, hsMetaFilePaths: string[], existingUids?: string[], options?: {
+    currentProjectMetadata?: ProjectMetadata;
+    updatedProjectMetadata?: ProjectMetadata;
+    showSuccessMessage?: boolean;
+    isProjectEmpty?: boolean;
+    projectDest?: string;
+}): Promise<void>;

package/lib/projects/components.js

@@ -6,8 +6,59 @@ import { uiLogger } from '../ui/logger.js';
 import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
 import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
+import { uiLink } from '../ui/index.js';
+import chalk from 'chalk';
+import { renderInline } from '../../ui/index.js';
+import { getSuccessBox } from '../../ui/components/StatusMessageBoxes.js';
 // Prefix for the metafile extension
 const metafileExtensionPrefix = path.parse(metafileExtension).name;
+function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
+    const lines = [];
+    lines.push(chalk.bold(projectName));
+    const types = Array.from(componentsByType.keys());
+    for (const uid of uids) {
+        lines.push(`├─ [app] ${uid}`);
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            const allComponents = componentsByType.get(type) || [];
+            const components = showOnlyNew
+                ? allComponents.filter(c => c.isNew)
+                : allComponents;
+            if (components.length === 0)
+                continue;
+            const isLastType = i === types.length - 1;
+            const typePrefix = isLastType ? '│  └─' : '│  ├─';
+            const typeConnector = isLastType ? '   ' : '│  ';
+            lines.push(`${typePrefix} ${type}`);
+            for (let j = 0; j < components.length; j++) {
+                const component = components[j];
+                const isLastComponent = j === components.length - 1;
+                const componentPrefix = isLastComponent ? '└─' : '├─';
+                const addedLabel = component.isNew ? chalk.green(' (added)') : '';
+                lines.push(`│  ${typeConnector}${componentPrefix} ${component.filename}${addedLabel}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function buildSuccessMessage(projectName, uids, componentsByType, newComponentsCount, showOnlyNew, isProjectEmpty, projectDest) {
+    const messages = lib.projects.components.buildSuccessMessage;
+    const tree = buildProjectTree(projectName, uids, componentsByType, showOnlyNew);
+    const featureText = `${newComponentsCount} feature${newComponentsCount > 1 ? 's' : ''}`;
+    const uid = uids.length === 1 ? uids[0] : projectName;
+    const docsLink = uiLink(messages.seeOurDocs, messages.docsUrl);
+    const header = projectDest
+        ? messages.headerCreated(projectName, projectDest)
+        : messages.headerAdded(featureText, uid, newComponentsCount > 1);
+    // Use \n\n between sections to create gaps, \n within sections for no gaps
+    const sections = [
+        header,
+        isProjectEmpty ? null : tree,
+        messages.docsDetails(docsLink),
+        `${messages.uploadPrompt}\n${messages.devPrompt}`,
+    ].filter(Boolean);
+    return sections.join('\n\n');
+}
 function applyDifferentiatorToFilename(filename, differentiator, isHsMetaFile) {
     const { name, ext, dir } = path.parse(filename);
     if (isHsMetaFile) {
@@ -120,9 +171,7 @@ 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);
+export async function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids = [], options) {
     for (const hsMetaFile of hsMetaFilePaths) {
         try {
             const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
@@ -142,10 +191,6 @@ export function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFile
             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));
         }
@@ -154,5 +199,43 @@ export function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFile
             uiLogger.error(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.failedToUpdate(hsMetaFile));
         }
     }
-    uiLogger.log('');
+    if (options?.showSuccessMessage && options?.updatedProjectMetadata) {
+        const { currentProjectMetadata, updatedProjectMetadata, isProjectEmpty, projectDest, } = options;
+        const uids = [];
+        const updatedAppsMetadata = updatedProjectMetadata.components[AppKey];
+        // Get UID(s) from -hsmeta.json files
+        if (updatedAppsMetadata?.hsMetaFiles) {
+            updatedAppsMetadata.hsMetaFiles.forEach(appLocation => {
+                try {
+                    const appConfig = JSON.parse(fs.readFileSync(appLocation, 'utf-8'));
+                    uids.push(appConfig.uid || 'unknown app'); // fallback to unknown app incase we can't get uid
+                }
+                catch (err) {
+                    uiLogger.debug(lib.projects.components.unableToGetUidFromHsmeta);
+                }
+            });
+        }
+        // Fallback if no app hsmeta files found or all failed to parse
+        if (uids.length === 0) {
+            uids.push('unknown app');
+        }
+        const componentsByType = new Map();
+        const addComponent = (hsMetaPath, isNew) => {
+            const type = path.basename(path.dirname(hsMetaPath));
+            const existing = componentsByType.get(type) || [];
+            existing.push({ filename: path.basename(hsMetaPath), isNew });
+            componentsByType.set(type, existing);
+        };
+        // Add new files
+        hsMetaFilePaths.forEach(hsMetaFile => addComponent(hsMetaFile, true));
+        if (currentProjectMetadata) {
+            Object.entries(currentProjectMetadata.components)
+                .filter(([type, metadata]) => type !== AppKey && metadata.count > 0)
+                .flatMap(([, metadata]) => metadata.hsMetaFiles)
+                .forEach(hsMetaFile => addComponent(hsMetaFile, false));
+        }
+        const newComponentsCount = hsMetaFilePaths.length;
+        const successMessage = buildSuccessMessage(projectName, uids, componentsByType, newComponentsCount, false, isProjectEmpty, projectDest);
+        await renderInline(getSuccessBox({ title: 'SUCCESS', message: successMessage }));
+    }
 }