@hubspot/cli 7.8.0-beta.0 → 7.8.0-beta.1

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

@@ -11,7 +11,7 @@ vi.mock('@hubspot/ui-extensions-dev-server', () => {
     };
 });
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
 import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
 import { requestPorts } from '@hubspot/local-dev-lib/portManager';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
@@ -109,8 +109,8 @@ describe('AppDevModeInterface', () => {
         LocalDevState.mockImplementation(() => mockLocalDevState);
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
         // Mock external dependencies
-        fetchPublicAppsForPortal.mockResolvedValue({
-            data: { results: [mockPublicApp] },
+        fetchAppMetadataByUid.mockResolvedValue({
+            data: mockPublicApp,
         });
         fetchPublicAppProductionInstallCounts.mockResolvedValue({
             data: { uniquePortalInstallCount: 5 },
@@ -129,7 +129,16 @@ describe('AppDevModeInterface', () => {
         getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
         getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
         installAppAutoPrompt.mockResolvedValue(true);
-        installAppBrowserPrompt.mockResolvedValue(undefined);
+        installAppBrowserPrompt.mockImplementation(async () => {
+            setTimeout(() => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+            }, 0);
+            return undefined;
+        });
         confirmPrompt.mockResolvedValue(true);
         installStaticAuthAppOnTestAccount.mockResolvedValue(undefined);
         // Mock process.exit
@@ -191,12 +200,12 @@ describe('AppDevModeInterface', () => {
         it('should return early if no app node exists', async () => {
             mockLocalDevState.projectNodes = {};
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).not.toHaveBeenCalled();
+            expect(fetchAppMetadataByUid).not.toHaveBeenCalled();
             expect(UIEDevModeInterface.setup).not.toHaveBeenCalled();
         });
         it('should setup successfully with private app', async () => {
             await appDevModeInterface.setup({});
-            expect(fetchPublicAppsForPortal).toHaveBeenCalledWith(12345);
+            expect(fetchAppMetadataByUid).toHaveBeenCalledWith('test-app-uid', 12345);
             expect(fetchPublicAppProductionInstallCounts).toHaveBeenCalledWith(123, 12345);
             expect(fetchAppInstallationData).toHaveBeenCalledWith(67890, 999, 'test-app-uid', ['test-scope'], []);
             expect(UIEDevModeInterface.setup).toHaveBeenCalled();
@@ -242,21 +251,16 @@ describe('AppDevModeInterface', () => {
             await newAppDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(0);
         });
-        // @TODO: Restore test account auto install functionality
-        // it('should auto-install static auth app on test account', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   await appDevModeInterface.setup({});
-        //   expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(
-        //     123,
-        //     67890,
-        //     [1, 2, 3]
-        //   );
-        // });
+        it('should auto-install static auth app on test account', async () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            await appDevModeInterface.setup({});
+            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
+        });
         it('should open browser for OAuth app installation', async () => {
             const oauthAppNode = {
                 ...mockAppNode,
@@ -295,81 +299,47 @@ describe('AppDevModeInterface', () => {
                 },
             });
             await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true, {
-                appUid: 'test-app-uid',
-                projectAccountId: 12345,
-                projectName: 'test-project',
-                testingAccountId: 67890,
-            });
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
-            fetchPublicAppsForPortal.mockRejectedValue(error);
+            fetchAppMetadataByUid.mockRejectedValue(error);
             await appDevModeInterface.setup({});
             expect(logError).toHaveBeenCalledWith(error);
         });
-        it('should exit if app not found in portal', async () => {
-            // Set up conditions for non-automatic installation to force getAppInstallUrl call
-            getAccountConfig.mockReturnValue(null);
-            // First call for fetchAppData succeeds
-            fetchPublicAppsForPortal
-                .mockResolvedValueOnce({
-                data: { results: [mockPublicApp] },
-            })
-                // Second call for getAppInstallUrl fails (app not found)
-                .mockResolvedValueOnce({
-                data: { results: [] },
+        it('should exit if user declines auto-install', async () => {
+            // Set up conditions for automatic installation
+            getAccountConfig.mockReturnValue({
+                parentAccountId: 12345, // matches targetProjectAccountId
             });
+            isDeveloperTestAccount.mockReturnValue(true);
             fetchAppInstallationData.mockResolvedValue({
                 data: {
                     isInstalledWithScopeGroups: false,
                     previouslyAuthorizedScopeGroups: [],
                 },
             });
+            installAppAutoPrompt.mockResolvedValue(false);
+            // Create a new instance to trigger the exit during setup
+            const newAppDevModeInterface = new AppDevModeInterface({
+                localDevState: mockLocalDevState,
+                localDevLogger: mockLocalDevLogger,
+            });
             // The setup method catches the error, so we check that process.exit was called
+            await newAppDevModeInterface.setup({});
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+        it('should fallback to browser install if auto-install fails', async () => {
+            fetchAppInstallationData.mockResolvedValue({
+                data: {
+                    isInstalledWithScopeGroups: false,
+                    previouslyAuthorizedScopeGroups: [],
+                },
+            });
+            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
             await appDevModeInterface.setup({});
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-        // @TODO: Restore test account auto install functionality
-        // it('should exit if user declines auto-install', async () => {
-        //   // Set up conditions for automatic installation
-        //   (getAccountConfig as Mock).mockReturnValue({
-        //     parentAccountId: 12345, // matches targetProjectAccountId
-        //   });
-        //   (isDeveloperTestAccount as Mock).mockReturnValue(true);
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installAppAutoPrompt as Mock).mockResolvedValue(false);
-        //   // Create a new instance to trigger the exit during setup
-        //   const newAppDevModeInterface = new AppDevModeInterface({
-        //     localDevState: mockLocalDevState,
-        //     localDevLogger: mockLocalDevLogger,
-        //   });
-        //   // The setup method catches the error, so we check that process.exit was called
-        //   await newAppDevModeInterface.setup({});
-        //   expect(process.exit).toHaveBeenCalledWith(0);
-        // });
-        // @TODO: Restore test account auto install functionality
-        // it('should fallback to browser install if auto-install fails', async () => {
-        //   (fetchAppInstallationData as Mock).mockResolvedValue({
-        //     data: {
-        //       isInstalledWithScopeGroups: false,
-        //       previouslyAuthorizedScopeGroups: [],
-        //     },
-        //   });
-        //   (installStaticAuthAppOnTestAccount as Mock).mockRejectedValue(
-        //     new Error('Install failed')
-        //   );
-        //   await appDevModeInterface.setup({});
-        //   expect(installAppBrowserPrompt).toHaveBeenCalledWith(
-        //     'http://static-install-url',
-        //     false
-        //   );
-        // });
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
+        });
     });
     describe('start()', () => {
         it('should return early if no app node exists', async () => {
@@ -426,14 +396,21 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                if (addListenerCall) {
+                    const callback = addListenerCall[1];
+                    callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                }
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -459,14 +436,23 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getOauthAppInstallUrl.mockReturnValue('http://oauth-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();
@@ -503,14 +489,23 @@ describe('AppDevModeInterface', () => {
             // Reset mocks to ensure clean state
             vi.clearAllMocks();
             // Set up basic mocks
-            fetchPublicAppsForPortal.mockResolvedValue({
-                data: { results: [mockPublicApp] },
+            fetchAppMetadataByUid.mockResolvedValue({
+                data: mockPublicApp,
             });
             fetchPublicAppProductionInstallCounts.mockResolvedValue({
                 data: { uniquePortalInstallCount: 5 },
             });
             getStaticAuthAppInstallUrl.mockReturnValue('http://static-install-url');
-            installAppBrowserPrompt.mockResolvedValue(undefined);
+            installAppBrowserPrompt.mockImplementation(async () => {
+                setTimeout(() => {
+                    const addListenerCall = mockLocalDevState.addListener.mock.calls.find(call => call[0] === 'devServerMessage');
+                    if (addListenerCall) {
+                        const callback = addListenerCall[1];
+                        callback(LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS);
+                    }
+                }, 0);
+                return undefined;
+            });
             // Reset the mock LocalDevState
             mockLocalDevState.getAppDataByUid = vi.fn().mockReturnValue(mockAppData);
             mockLocalDevState.setAppDataForUid = vi.fn();

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

@@ -7,7 +7,7 @@ import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import LocalDevProcess from '../localDev/LocalDevProcess.js';
 import LocalDevLogger from '../localDev/LocalDevLogger.js';
-import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
+import DevServerManager from '../localDev/DevServerManager.js';
 import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
 import { vi } from 'vitest';
 // Mock @hubspot/ui-extensions-dev-server
@@ -27,7 +27,7 @@ vi.mock('../config');
 vi.mock('@hubspot/local-dev-lib/api/projects');
 vi.mock('@hubspot/local-dev-lib/errors/index');
 vi.mock('../localDev/LocalDevLogger');
-vi.mock('../localDev/DevServerManagerV2');
+vi.mock('../localDev/DevServerManager');
 // Tests for LocalDevProcess and LocalDevState
 describe('LocalDevProcess', () => {
     let mockLocalDevLogger;
@@ -67,6 +67,7 @@ describe('LocalDevProcess', () => {
                 subbuildStatuses: [],
                 uploadMessage: 'Build completed',
                 autoDeployId: 0,
+                platformVersion: '2025.2',
             },
         },
         initialProjectNodes: {},
@@ -104,7 +105,7 @@ describe('LocalDevProcess', () => {
         };
         // Mock constructors
         LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
-        DevServerManagerV2.mockImplementation(() => mockDevServerManager);
+        DevServerManager.mockImplementation(() => mockDevServerManager);
         // Mock external functions
         isHubSpotHttpError.mockReturnValue(false);
         // Create process instance
@@ -398,7 +399,7 @@ describe('LocalDevProcess', () => {
             expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
             'test-project', // projectName
             123, // buildId
-            true, // useV3Api
+            true, // useV2Api
             false // force
             );
             expect(mockLocalDevLogger.deploySuccess).toHaveBeenCalled();
@@ -426,7 +427,7 @@ describe('LocalDevProcess', () => {
             expect(handleProjectDeploy).toHaveBeenCalledWith(123, // targetProjectAccountId
             'test-project', // projectName
             123, // buildId
-            true, // useV3Api
+            true, // useV2Api
             true // force
             );
             expect(result).toEqual({

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

@@ -252,7 +252,7 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
             expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
             // Each connection should trigger state listener setup
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(9); // 3 listeners per connection * 3 connections
+            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(12); // 4 listeners per connection * 3 connections
             // Each connection should trigger dev server message
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
             expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
@@ -308,16 +308,16 @@ describe('LocalDevWebsocketServer', () => {
             const closeCallbacks2 = mockWebSocket2.on.mock.calls
                 .filter(call => call[0] === 'close')
                 .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
-            expect(closeCallbacks2).toHaveLength(3); // projectNodes, appData, and uploadWarnings listeners
+            expect(closeCallbacks1).toHaveLength(4); // projectNodes, appData, devServersStarted, and uploadWarnings listeners
+            expect(closeCallbacks2).toHaveLength(4); // projectNodes, appData, devServersStarted, and uploadWarnings listeners
             // Simulate first connection closing (call all close callbacks)
             closeCallbacks1.forEach(callback => callback());
-            // Should have removed listeners for first connection (3 listeners: projectNodes, appData, and uploadWarnings)
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(3);
+            // Should have removed listeners for first connection (4 listeners: projectNodes, appData, devServersStarted, and uploadWarnings)
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
             // Simulate second connection closing
             closeCallbacks2.forEach(callback => callback());
             // Should have removed listeners for second connection as well
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(6);
+            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(8);
         });
         it('should broadcast state changes to all connected clients', () => {
             // Establish connections

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__/{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);