@hubspot/cli 7.8.0-experimental.0 → 7.8.0

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,9 +126,9 @@ describe('lib/projects/deploy', () => {
                 data: mockDeployResponseData,
             });
             mockPollDeployStatus.mockResolvedValue(mockDeployResult);
-            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
-            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
-            expect(result).toEqual(mockDeployResult);
+            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 () => {
             const mockBlockedResponse = {
@@ -150,15 +150,80 @@ describe('lib/projects/deploy', () => {
             mockDeployProject.mockResolvedValue({
                 data: mockBlockedResponse,
             });
-            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            await handleProjectDeploy(targetAccountId, projectName, buildId, useV2Api, force);
             expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
-            expect(result).toBeUndefined();
+        });
+        it('handles blocked deploy with errors (cannot be forced)', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [
+                            {
+                                message: 'This is an error',
+                                isWarning: false,
+                            },
+                        ],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            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'));
+        });
+        it('handles blocked deploy with no blocking messages', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            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 result = 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, useV2Api, force);
             expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
-            expect(result).toBeUndefined();
+            expect(deploy).toBeUndefined();
+        });
+        it('passes correct parameters to deployProject', async () => {
+            const mockDeployResponseData = {
+                id: 'deploy-123',
+                buildResultType: 'DEPLOY_QUEUED',
+                links: {
+                    status: 'http://status-url',
+                },
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockDeployResponseData,
+            });
+            mockPollDeployStatus.mockResolvedValue({});
+            await handleProjectDeploy(targetAccountId, projectName, buildId, false, true);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, false, // useV2Api
+            true // force
+            );
         });
     });
 });

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

@@ -30,6 +30,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
             componentRoot: '/local/path',
             componentConfigPath: '/local/path/config.json',
             configUpdatedSinceLastUpload: false,
+            removed: false,
+            parsingErrors: [],
         },
         componentDeps: {},
         metaFilePath: '/local/path',
@@ -99,7 +101,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
         it('should clean up temp directory even when errors occur', async () => {
             // Mock downloadProject to throw an error after temp dir is created
             downloadProject.mockRejectedValue(new Error('Download Error'));
-            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Download Error');
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
             expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
         });
         it('should handle translateForLocalDev errors', async () => {
@@ -111,7 +114,8 @@ describe('isDeployedProjectUpToDateWithLocal', () => {
             extractZipArchive.mockResolvedValue(undefined);
             // Mock translate to throw an error
             translate.mockRejectedValue(new Error('Translation Error'));
-            await expect(isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes)).rejects.toThrow('Translation Error');
+            const result = await isDeployedProjectUpToDateWithLocal(mockProjectConfig, mockAccountId, mockBuildId, mockLocalProjectNodes);
+            expect(result).toBe(false);
             expect(fs.remove).toHaveBeenCalledWith(mockTempDir);
         });
     });

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

@@ -1,23 +1,23 @@
-import { useV3Api } from '../platformVersion.js';
+import { isV2Project } from '../platformVersion.js';
 describe('platformVersion', () => {
-    describe('useV3Api', () => {
+    describe('isV2Project', () => {
         it('returns true if platform version is UNSTABLE', () => {
-            expect(useV3Api('UNSTABLE')).toBe(true);
+            expect(isV2Project('UNSTABLE')).toBe(true);
         });
         it('returns true if platform version is equal to the minimum', () => {
-            expect(useV3Api('2025.2')).toBe(true);
+            expect(isV2Project('2025.2')).toBe(true);
         });
         it('returns true if platform version is greater than the minimum', () => {
-            expect(useV3Api('2026.2')).toBe(true);
+            expect(isV2Project('2026.2')).toBe(true);
         });
         it('returns false if platform version is less than the minimum', () => {
-            expect(useV3Api('2025.0')).toBe(false);
+            expect(isV2Project('2025.0')).toBe(false);
         });
         it('returns false if platform version is invalid', () => {
-            expect(useV3Api(null)).toBe(false);
+            expect(isV2Project(null)).toBe(false);
         });
         it('returns false for an invalid platform version', () => {
-            expect(useV3Api('notplaformversion')).toBe(false);
+            expect(isV2Project('notplaformversion')).toBe(false);
         });
     });
 });

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

@@ -3,8 +3,8 @@ import os from 'os';
 import path from 'path';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { validateProjectConfig } from '../../projects/config.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
-vi.mock('@hubspot/local-dev-lib/logger');
+import { uiLogger } from '../../ui/logger.js';
+vi.mock('../../ui/logger.js');
 describe('lib/projects', () => {
     describe('validateProjectConfig()', () => {
         let projectDir;
@@ -26,58 +26,58 @@ describe('lib/projects', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig(null, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
         });
         it('rejects configuration with missing name', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig({ srcDir: '.' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
         });
         it('rejects configuration with missing srcDir', () => {
             // @ts-ignore Testing invalid input
             validateProjectConfig({ name: 'hello' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
         });
         describe('rejects configuration with srcDir outside project directory', () => {
             it('for parent directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
             });
             it('for root directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
             });
             it('for complicated directory', () => {
                 const srcDir = './src/././../src/../../src';
                 validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir);
                 expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
+                expect(uiLogger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
             });
         });
         it('rejects configuration with srcDir that does not exist', () => {
             validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir);
             expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
+            expect(uiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
         });
         describe('accepts configuration with valid srcDir', () => {
             it('for current directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
             it('for relative directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
             it('for implied relative directory', () => {
                 validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir);
                 expect(exitMock).not.toHaveBeenCalled();
-                expect(logger.error).not.toHaveBeenCalled();
+                expect(uiLogger.error).not.toHaveBeenCalled();
             });
         });
     });

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

@@ -1,11 +1,11 @@
 import fs from 'fs';
 import * as HSfs from '@hubspot/local-dev-lib/fs';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../ui/logger.js';
 import { getComponentTypeFromConfigFile, loadConfigFile, getAppCardConfigs, getIsLegacyApp, componentIsApp, findProjectComponents, getProjectComponentTypes, getComponentUid, componentIsPublicApp, } from '../structure.js';
 import { ComponentTypes } from '../../../types/Projects.js';
 vi.mock('fs');
 vi.mock('@hubspot/local-dev-lib/fs');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../ui/logger.js');
 const mockedReadFileSync = fs.readFileSync;
 const mockedWalk = HSfs.walk;
 const getMockPrivateAppConfig = (cards = []) => ({
@@ -46,7 +46,7 @@ describe('lib/projects/structure', () => {
                 throw new Error('File not found');
             });
             expect(loadConfigFile('nonexistent/path/app.json')).toBeNull();
-            expect(logger.debug).toHaveBeenCalled();
+            expect(uiLogger.debug).toHaveBeenCalled();
         });
     });
     describe('getAppCardConfigs()', () => {

package/lib/projects/__tests__/upload.test.d.ts

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

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

@@ -0,0 +1,82 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { vi } from 'vitest';
+import { validateSourceDirectory } from '../upload.js';
+import { uiLogger } from '../../ui/logger.js';
+import { lib } from '../../../lang/en.js';
+import { isV2Project } from '../platformVersion.js';
+import ProjectValidationError from '../../errors/ProjectValidationError.js';
+import { walk } from '@hubspot/local-dev-lib/fs';
+// Mock dependencies
+vi.mock('../../ui/logger.js');
+vi.mock('../platformVersion.js');
+vi.mock('@hubspot/local-dev-lib/fs');
+describe('lib/projects/upload', () => {
+    describe('validateSourceDirectory', () => {
+        let tempDir;
+        let srcDir;
+        let projectConfig;
+        beforeEach(() => {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'upload-test-'));
+            srcDir = path.join(tempDir, 'src');
+            fs.mkdirSync(srcDir, { recursive: true });
+            projectConfig = {
+                name: 'test-project',
+                srcDir: 'src',
+                platformVersion: '2025.2',
+            };
+            vi.clearAllMocks();
+        });
+        afterEach(() => {
+            fs.removeSync(tempDir);
+        });
+        it('should throw ProjectValidationError when source directory is empty', async () => {
+            vi.mocked(walk).mockResolvedValue([]);
+            await expect(validateSourceDirectory(srcDir, projectConfig, tempDir)).rejects.toThrow(ProjectValidationError);
+            expect(walk).toHaveBeenCalledWith(srcDir, ['node_modules']);
+        });
+        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]);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app/serverless.json', '2025.2'));
+        });
+        it('should warn about multiple legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'app1', 'serverless.json'),
+                path.join(srcDir, 'app2', 'app.json'),
+                path.join(srcDir, 'app3', 'public-app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).toHaveBeenCalledTimes(3);
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app1/serverless.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app2/app.json', '2025.2'));
+            expect(uiLogger.warn).toHaveBeenCalledWith(lib.projectUpload.handleProjectUpload.legacyFileDetected('src/app3/public-app.json', '2025.2'));
+        });
+        it('should not warn about non-legacy files', async () => {
+            vi.mocked(isV2Project).mockReturnValue(true);
+            const filePaths = [
+                path.join(srcDir, 'component.js'),
+                path.join(srcDir, 'config.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).not.toHaveBeenCalled();
+        });
+        it('should not warn about legacy files in non-V2 projects', async () => {
+            vi.mocked(isV2Project).mockReturnValue(false);
+            projectConfig.platformVersion = '2025.1';
+            const filePaths = [
+                path.join(srcDir, 'app', 'serverless.json'),
+                path.join(srcDir, 'app', 'app.json'),
+            ];
+            vi.mocked(walk).mockResolvedValue(filePaths);
+            await validateSourceDirectory(srcDir, projectConfig, tempDir);
+            expect(uiLogger.warn).not.toHaveBeenCalled();
+        });
+    });
+});

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

@@ -2,7 +2,7 @@ import { legacyAddComponent } from '../legacyAddComponent.js';
 import { findProjectComponents } from '../../structure.js';
 import { getProjectComponentListFromRepo } from '../../create/legacy.js';
 import { projectAddPrompt } from '../../../prompts/projectAddPrompt.js';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../../ui/logger.js';
 import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
 import { trackCommandUsage } from '../../../usageTracking.js';
 import { ComponentTypes, } from '../../../../types/Projects.js';
@@ -10,13 +10,13 @@ import { commands } from '../../../../lang/en.js';
 vi.mock('../../structure');
 vi.mock('../../create/legacy');
 vi.mock('../../../prompts/projectAddPrompt');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/local-dev-lib/github');
 vi.mock('../../../usageTracking.js');
 const mockedFindProjectComponents = vi.mocked(findProjectComponents);
 const mockedGetProjectComponentListFromRepo = vi.mocked(getProjectComponentListFromRepo);
 const mockedProjectAddPrompt = vi.mocked(projectAddPrompt);
-const mockedLogger = vi.mocked(logger);
+const mockedUiLogger = vi.mocked(uiLogger);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
 const mockedTrackCommandUsage = vi.mocked(trackCommandUsage);
 describe('lib/projects/add/legacyAddComponent', () => {
@@ -75,8 +75,8 @@ describe('lib/projects/add/legacyAddComponent', () => {
             expect(mockedTrackCommandUsage).toHaveBeenCalledWith('project-add', {
                 type: 'module',
             }, accountId);
-            expect(mockedLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
-            expect(mockedLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(commands.project.add.creatingComponent('test-project'));
+            expect(mockedUiLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
         });
         it('throws an error when project contains a public app', async () => {
             const mockComponents = [
@@ -206,7 +206,7 @@ describe('lib/projects/add/legacyAddComponent', () => {
             mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
             await expect(legacyAddComponent(mockArgs, projectDir, mockProjectConfig, accountId)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
             expect(mockedCloneGithubRepo).toHaveBeenCalled();
-            expect(mockedLogger.success).not.toHaveBeenCalled();
+            expect(mockedUiLogger.success).not.toHaveBeenCalled();
         });
         it('calls trackCommandUsage with correct component type', async () => {
             const mockComponents = [

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,37 +1,37 @@
 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 { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from '../../../ui/logger.js';
 import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
 import { trackCommandUsage } from '../../../usageTracking.js';
 import { commands } from '../../../../lang/en.js';
 vi.mock('fs');
 vi.mock('../../../prompts/promptUtils');
 vi.mock('../../create/legacy');
-vi.mock('../../create/v3');
+vi.mock('../../create/v2');
 vi.mock('../../../prompts/projectAddPrompt');
 vi.mock('@hubspot/local-dev-lib/github');
-vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../../../ui/logger.js');
 vi.mock('@hubspot/project-parsing-lib/src/lib/project');
 vi.mock('../../../usageTracking');
 const mockedFs = vi.mocked(fs);
 const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
 const mockedConfirmPrompt = vi.mocked(confirmPrompt);
-const mockedCreateV3App = vi.mocked(createV3App);
-const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
+const mockedCreateV2App = vi.mocked(createV2App);
+const mockedProjectAddPromptV2 = vi.mocked(projectAddPromptV2);
 const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
-const mockedLogger = vi.mocked(logger);
+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,21 +86,21 @@ 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',
             }));
-            expect(mockedLogger.success).toHaveBeenCalled();
+            expect(mockedUiLogger.success).toHaveBeenCalled();
         });
         it('creates an app when no app exists and user confirms', async () => {
             const mockProjectMetadataNoApps = {
@@ -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[];