@hubspot/cli 7.8.12-experimental.1 → 7.9.0-beta.1

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

@@ -0,0 +1,161 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import UIExtensionsDevModeInterface from '../localDev/UIExtensionsDevModeInterface.js';
+import LocalDevState from '../localDev/LocalDevState.js';
+import { DevModeUnifiedInterface } from '@hubspot/ui-extensions-dev-server';
+import { requestPorts } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+    DevModeUnifiedInterface: {
+        setup: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        fileChange: vi.fn().mockResolvedValue(undefined),
+        cleanup: vi.fn().mockResolvedValue(undefined),
+    },
+}));
+vi.mock('@hubspot/local-dev-lib/portManager', () => ({
+    requestPorts: vi.fn().mockResolvedValue({ 'test-port': 8080 }),
+}));
+vi.mock('@hubspot/local-dev-lib/urls', () => ({
+    getHubSpotApiOrigin: vi.fn().mockReturnValue('https://api.hubspot.com'),
+    getHubSpotWebsiteOrigin: vi.fn().mockReturnValue('https://app.hubspot.com'),
+}));
+describe('UIExtensionsDevModeInterface', () => {
+    let uiExtensionsInterface;
+    let mockLocalDevState;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(DevModeUnifiedInterface.setup).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.start).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.fileChange).mockResolvedValue(undefined);
+        vi.mocked(DevModeUnifiedInterface.cleanup).mockResolvedValue(undefined);
+        mockLocalDevState = new LocalDevState({
+            targetProjectAccountId: 123,
+            targetTestingAccountId: 456,
+            projectConfig: {
+                name: 'test-ui-extensions-project',
+                srcDir: 'src',
+                platformVersion: '1.0.0',
+            },
+            projectDir: '/test/ui-extensions-project',
+            projectData: {
+                name: 'test-ui-extensions-project',
+                id: 789,
+                createdAt: Date.now(),
+                deletedAt: 0,
+                isLocked: false,
+                portalId: 123,
+                updatedAt: Date.now(),
+            },
+            debug: false,
+            initialProjectNodes: {
+                'test-component': {
+                    uid: 'test-component-uid',
+                    componentType: 'UI_EXTENSION',
+                    config: {
+                        name: 'Test UI Extension',
+                        type: 'card',
+                    },
+                    localDev: {
+                        componentRoot: '/test/path',
+                        componentConfigPath: '/test/path/config.json',
+                        configUpdatedSinceLastUpload: false,
+                        removed: false,
+                        parsingErrors: [],
+                    },
+                    componentDeps: {},
+                    metaFilePath: '/test/path',
+                    files: [],
+                },
+            },
+            initialProjectProfileData: {
+                testVariable: 'testValue',
+            },
+            profile: 'test',
+            env: ENVIRONMENTS.QA,
+        });
+        uiExtensionsInterface = new UIExtensionsDevModeInterface({
+            localDevState: mockLocalDevState,
+        });
+    });
+    describe('constructor', () => {
+        it('should store the localDevState reference', () => {
+            expect(uiExtensionsInterface.localDevState).toBe(mockLocalDevState);
+        });
+    });
+    describe('setup', () => {
+        it('should call DevModeUnifiedInterface.setup with correct parameters', async () => {
+            await uiExtensionsInterface.setup();
+            expect(DevModeUnifiedInterface.setup).toHaveBeenCalledWith({
+                components: mockLocalDevState.projectNodes,
+                profileData: mockLocalDevState.projectProfileData,
+                logger,
+                urls: {
+                    api: 'https://api.hubspot.com',
+                    web: 'https://app.hubspot.com',
+                },
+            });
+        });
+        it('should use correct URLs based on environment', async () => {
+            await uiExtensionsInterface.setup();
+            expect(getHubSpotApiOrigin).toHaveBeenCalledWith(mockLocalDevState.env);
+            expect(getHubSpotWebsiteOrigin).toHaveBeenCalledWith(mockLocalDevState.env);
+        });
+        it('should pass project nodes and profile data from state', async () => {
+            await uiExtensionsInterface.setup();
+            const setupCall = vi.mocked(DevModeUnifiedInterface.setup).mock
+                .calls[0][0];
+            expect(setupCall.components).toStrictEqual(mockLocalDevState.projectNodes);
+            expect(setupCall.profileData).toStrictEqual(mockLocalDevState.projectProfileData);
+        });
+    });
+    describe('start', () => {
+        it('should call DevModeUnifiedInterface.start with correct parameters', async () => {
+            await uiExtensionsInterface.start();
+            expect(DevModeUnifiedInterface.start).toHaveBeenCalledWith({
+                accountId: mockLocalDevState.targetTestingAccountId,
+                projectConfig: mockLocalDevState.projectConfig,
+                requestPorts,
+            });
+        });
+        it('should use targetTestingAccountId from state', async () => {
+            await uiExtensionsInterface.start();
+            const startCall = vi.mocked(DevModeUnifiedInterface.start).mock
+                .calls[0][0];
+            expect(startCall.accountId).toBe(456); // targetTestingAccountId
+        });
+        it('should pass project config from state', async () => {
+            await uiExtensionsInterface.start();
+            const startCall = vi.mocked(DevModeUnifiedInterface.start).mock
+                .calls[0][0];
+            expect(startCall.projectConfig).toStrictEqual(mockLocalDevState.projectConfig);
+        });
+    });
+    describe('fileChange', () => {
+        it('should call DevModeUnifiedInterface.fileChange with correct parameters', async () => {
+            const filePath = 'src/components/TestCard.tsx';
+            const event = 'change';
+            await uiExtensionsInterface.fileChange(filePath, event);
+            expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledWith(filePath, event);
+        });
+        it('should handle different file events', async () => {
+            const testCases = [
+                { filePath: 'src/components/Card.tsx', event: 'add' },
+                { filePath: 'src/styles/main.css', event: 'change' },
+                { filePath: 'src/config.json', event: 'unlink' },
+            ];
+            for (const testCase of testCases) {
+                await uiExtensionsInterface.fileChange(testCase.filePath, testCase.event);
+                expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledWith(testCase.filePath, testCase.event);
+            }
+            expect(DevModeUnifiedInterface.fileChange).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('cleanup', () => {
+        it('should call DevModeUnifiedInterface.cleanup', async () => {
+            await uiExtensionsInterface.cleanup();
+            expect(DevModeUnifiedInterface.cleanup).toHaveBeenCalledWith();
+        });
+    });
+});

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

@@ -99,7 +99,7 @@ describe('lib/projects/deploy', () => {
         const targetAccountId = 12345;
         const projectName = 'test-project';
         const buildId = 5;
-        const useV3Api = true;
+        const useV2Api = true;
         const force = false;
         it('successfully deploys and returns deploy result', async () => {
             const mockDeployResponseData = {
@@ -126,8 +126,8 @@ describe('lib/projects/deploy', () => {
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue(mockDeployResult);
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV2Api, force);
             expect(deploy).toEqual(mockDeployResult);
         });
         it('handles blocked deploy with warnings', async () => {
@@ -150,7 +150,7 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
         });
         it('handles blocked deploy with errors (cannot be forced)', async () => {
@@ -173,7 +173,7 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deployBlockedHeader);
             expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployIssueComponentWarning('component-1', 'module', 'This is an error'));
         });
@@ -192,19 +192,19 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
             expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployIssueComponentGeneric('component-1', 'module'));
         });
         it('handles general deploy failure', async () => {
             mockDeployProject.mockResolvedValue({ data: null });
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            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 });
-            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            const deploy = await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
             expect(deploy).toBeUndefined();
         });
@@ -221,7 +221,7 @@ describe('lib/projects/deploy', () => {
             });
             mockPollDeployStatus.mockResolvedValue({});
             await handleProjectDeploy(targetAccountId, projectName, buildId, false, true);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV3Api
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV2Api
             true // force
             );
         });

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

@@ -36,7 +36,7 @@ describe('lib/projects/upload', () => {
             await expect(validateSourceDirectory(srcDir, projectConfig, tempDir)).rejects.toThrow(ProjectValidationError);
             expect(walk).toHaveBeenCalledWith(srcDir, ['node_modules']);
         });
-        it('should warn about legacy files in V3 projects', async () => {
+        it('should warn about legacy files in V2 projects', async () => {
             vi.mocked(isV2Project).mockReturnValue(true);
             const legacyFilePath = path.join(srcDir, 'app', 'serverless.json');
             vi.mocked(walk).mockResolvedValue([legacyFilePath]);
@@ -67,7 +67,7 @@ describe('lib/projects/upload', () => {
             await validateSourceDirectory(srcDir, projectConfig, tempDir);
             expect(uiLogger.warn).not.toHaveBeenCalled();
         });
-        it('should not warn about legacy files in non-V3 projects', async () => {
+        it('should not warn about legacy files in non-V2 projects', async () => {
             vi.mocked(isV2Project).mockReturnValue(false);
             projectConfig.platformVersion = '2025.1';
             const filePaths = [

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

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

package/lib/projects/add/__tests__/{v3AddComponent.test.js → v2AddComponent.test.js}

@@ -1,9 +1,9 @@
 import fs from 'fs';
-import { v3AddComponent } from '../v3AddComponent.js';
+import { v2AddComponent } from '../v2AddComponent.js';
 import { getConfigForPlatformVersion } from '../../create/legacy.js';
-import { createV3App } from '../../create/v3.js';
+import { createV2App } from '../../create/v2.js';
 import { confirmPrompt } from '../../../prompts/promptUtils.js';
-import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.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';
@@ -12,7 +12,7 @@ import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
 vi.mock('../../create/legacy');
-vi.mock('../../create/v3');
+vi.mock('../../create/v2');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('../../../ui/logger.js');
@@ -21,17 +21,17 @@ 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 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);
-describe('lib/projects/add/v3AddComponent', () => {
+describe('lib/projects/add/v2AddComponent', () => {
     const mockProjectConfig = {
         name: 'test-project',
         srcDir: 'src',
-        platformVersion: 'v3',
+        platformVersion: '2025.2',
     };
     const mockArgs = {
         name: 'test-component',
@@ -66,13 +66,13 @@ describe('lib/projects/add/v3AddComponent', () => {
         },
     };
     beforeEach(() => {
-        mockedCreateV3App.mockResolvedValue({
+        mockedCreateV2App.mockResolvedValue({
             authType: 'oauth',
             distribution: 'private',
         });
         mockedTrackCommandUsage.mockResolvedValue();
     });
-    describe('v3AddComponent()', () => {
+    describe('v2AddComponent()', () => {
         it('successfully adds a component when app already exists', async () => {
             const mockAppMeta = {
                 config: {
@@ -86,17 +86,17 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
-            expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('v3');
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('2025.2');
             expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
-            expect(mockedProjectAddPromptV3).toHaveBeenCalled();
+            expect(mockedProjectAddPromptV2).toHaveBeenCalled();
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'module',
             }, mockAccountId);
             expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
-                sourceDir: ['v3/test-component'],
+                sourceDir: ['2025.2/test-component'],
                 hideLogs: true,
                 branch: 'main',
             }));
@@ -116,15 +116,15 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
             mockedConfirmPrompt.mockResolvedValue(true);
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
-            expect(mockedCreateV3App).toHaveBeenCalled();
+            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: ['v3/test-component', 'v3/app-template'],
+                sourceDir: ['2025.2/test-component', '2025.2/app-template'],
             }));
         });
         it('should not call clone', async () => {
@@ -145,10 +145,10 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
             mockedConfirmPrompt.mockResolvedValue(true);
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
-            expect(mockedCreateV3App).not.toHaveBeenCalled();
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            expect(mockedCreateV2App).not.toHaveBeenCalled();
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: '',
             }, mockAccountId);
@@ -164,7 +164,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             };
             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');
+            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 = {
@@ -172,7 +172,7 @@ describe('lib/projects/add/v3AddComponent', () => {
                 parentComponents: [],
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            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);
@@ -180,7 +180,7 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedFs.readFileSync.mockImplementation(() => {
                 throw new Error('File read error');
             });
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
+            await expect(v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow('Unable to parse app file');
         });
         it('throws an error when cloning fails', async () => {
             const mockAppMeta = {
@@ -195,9 +195,9 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
-            await expect(v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+            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 = {
@@ -219,9 +219,9 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'module,card',
             }, mockAccountId);
@@ -243,8 +243,8 @@ describe('lib/projects/add/v3AddComponent', () => {
             };
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: '',
             }, mockAccountId);
@@ -270,9 +270,9 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'workflow-action-tool',
             }, mockAccountId);
@@ -308,9 +308,9 @@ describe('lib/projects/add/v3AddComponent', () => {
             mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
             mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
             mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
-            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedProjectAddPromptV2.mockResolvedValue(mockPromptResponse);
             mockedCloneGithubRepo.mockResolvedValue(true);
-            await v3AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
+            await v2AddComponent(mockArgs, projectDir, mockProjectConfig, mockAccountId);
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'workflow-action-tool,module',
             }, mockAccountId);

package/lib/projects/add/{v3AddComponent.d.ts → v2AddComponent.d.ts}

@@ -1,5 +1,5 @@
 import { ProjectConfig } from '../../../types/Projects.js';
-export declare function v3AddComponent(args: {
+export declare function v2AddComponent(args: {
     name?: string;
     type?: string;
     features?: string[];

package/lib/projects/add/{v3AddComponent.js → v2AddComponent.js}

@@ -1,10 +1,10 @@
 import { commands, lib } from '../../../lang/en.js';
 import { getConfigForPlatformVersion } from '../create/legacy.js';
-import { calculateComponentTemplateChoices, createV3App, } from '../create/v3.js';
+import { calculateComponentTemplateChoices, createV2App, } from '../create/v2.js';
 import { PROJECT_WITH_APP } from '../../constants.js';
 import path from 'path';
 import fs from 'fs';
-import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
+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/src/lib/project.js';
@@ -13,7 +13,7 @@ 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';
-export async function v3AddComponent(args, projectDir, projectConfig, accountId) {
+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;
@@ -27,7 +27,7 @@ export async function v3AddComponent(args, projectDir, projectConfig, accountId)
     const appsMetadata = currentProjectMetadata.components[AppKey];
     const shouldCreateApp = appsMetadata.count === 0;
     if (shouldCreateApp) {
-        const { authType, distribution } = await createV3App(args.auth, args.distribution);
+        const { authType, distribution } = await createV2App(args.auth, args.distribution);
         derivedDistribution = distribution;
         derivedAuthType = authType;
     }
@@ -47,7 +47,7 @@ export async function v3AddComponent(args, projectDir, projectConfig, accountId)
         derivedAuthType = apps[0].config?.auth?.type;
     }
     const componentTemplateChoices = await calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, args.derivedAccountId, currentProjectMetadata);
-    const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
+    const projectAddPromptResponse = await projectAddPromptV2(componentTemplateChoices, args.features);
     const componentTypes = projectAddPromptResponse.componentTemplate?.map(componentTemplate => componentTemplate.cliSelector || componentTemplate.type);
     await trackCommandUsage('project-add', {
         type: componentTypes?.join(','),

package/lib/projects/create/__tests__/v2.test.d.ts

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

package/lib/projects/create/__tests__/{v3.test.js → v2.test.js}

@@ -1,10 +1,10 @@
-import { calculateComponentTemplateChoices } from '../v3.js';
+import { calculateComponentTemplateChoices } from '../v2.js';
 import { hasFeature } from '../../../hasFeature.js';
 vi.mock('../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/api/github');
 vi.mock('../../../hasFeature.js');
 const mockHasFeature = vi.mocked(hasFeature);
-describe('lib/projects/create/v3', () => {
+describe('lib/projects/create/v2', () => {
     beforeEach(() => {
         mockHasFeature.mockResolvedValue(true);
     });

package/lib/projects/create/index.js

@@ -2,7 +2,7 @@ import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplat
 import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
 import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
 import { isV2Project } from '../platformVersion.js';
-import { v3ComponentFlow } from './v3.js';
+import { v2ComponentFlow } from './v2.js';
 import { getProjectTemplateListFromRepo } from './legacy.js';
 import { uiLogger } from '../../ui/logger.js';
 import { commands } from '../../../lang/en.js';
@@ -12,7 +12,7 @@ export async function handleProjectCreationFlow(args) {
     const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
     const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
     if (isV2Project(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
         const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {
             authType,

package/lib/projects/create/{v3.d.ts → v2.d.ts}

@@ -2,19 +2,19 @@ import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
 import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
-export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+export declare function createV2App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
     authType: string;
     distribution: string;
 }>;
 export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
-type V3ComponentInfo = {
+type V2ComponentInfo = {
     authType?: string;
     distribution?: string;
     repoConfig?: ProjectTemplateRepoConfig;
     projectContents?: string;
     componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
 };
-export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V3ComponentInfo>;
+export declare function v2ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V2ComponentInfo>;
 export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
     selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
     platformVersion: string;

package/lib/projects/create/{v3.js → v2.js}

@@ -10,7 +10,7 @@ import { logError } from '../../errorHandlers/index.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { hasFeature } from '../../hasFeature.js';
 import { AppEventsKey, PagesKey, } from '@hubspot/project-parsing-lib/src/lib/constants.js';
-export async function createV3App(providedAuth, providedDistribution) {
+export async function createV2App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&
         providedDistribution === marketplaceDistribution &&
@@ -112,7 +112,7 @@ export async function calculateComponentTemplateChoices(components, authType, di
         ]
         : [...enabledComponents];
 }
-export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
+export async function v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
     let repoConfig = undefined;
     let authType;
     let distribution;
@@ -134,7 +134,7 @@ export async function v3ComponentFlow(platformVersion, projectBase, providedAuth
             ],
         }));
     if (projectContentsChoice === PROJECT_WITH_APP) {
-        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV2App(providedAuth, providedDistribution);
         authType = selectedAuthType;
         distribution = selectedDistribution;
     }

package/lib/projects/deploy.d.ts

@@ -10,4 +10,4 @@ export declare function logDeployErrors(errorData: {
         };
     }>;
 }): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, useV3Api: boolean, force: boolean): Promise<Deploy | undefined>;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -47,8 +47,8 @@ function handleBlockedDeploy(deployResp) {
         uiLogger.log('');
     });
 }
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force) {
-    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, useV3Api, force);
+export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
+    const { data: deployResp } = await deployProject(targetAccountId, projectName, buildId, isV2Project, force);
     if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
         if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
             handleBlockedDeploy(deployResp);